diff --git a/scripts/vec_test_helpers/__init__.py b/scripts/vec_test_helpers/__init__.py
index 4aa284e..87f457e 100644
--- a/scripts/vec_test_helpers/__init__.py
+++ b/scripts/vec_test_helpers/__init__.py
@@ -14,7 +14,6 @@
         VECTOR = enum.auto()
         SCALAR = enum.auto()
         IMMEDIATE = enum.auto()
-        FLOATSCALAR = enum.auto()
 
     class OperandWidth(enum.Enum):
         """RISC-V V operand width type option."""
@@ -38,11 +37,6 @@
             OperandWidth.WIDENING: "vi",
             OperandWidth.NARROWING: "wi",
         },
-        OperandType.FLOATSCALAR : {
-            OperandWidth.STANDARD: "vf",
-            OperandWidth.WIDENING: "vf",
-            OperandWidth.NARROWING: "wf",
-        },
     }
 
     """Helper class for providing params for use in templates"""
@@ -58,14 +52,12 @@
             8:np.uint8,
             16:np.uint16,
             32:np.uint32}
-        self.float_np_types = {
-            32:np.float32}
 
     @property
     def op_code(self):
         """Return the op_code."""
         if self._op_code is None:
-            raise ValueError("OP CODE was not set.")
+            raise ValueError("SEW was not set.")
         return self._op_code
 
     @op_code.setter
@@ -73,10 +65,6 @@
         """Set the op_code"""
         self._op_code = value
 
-    def is_floating(self):
-        """check if a particular op_code is a floating type."""
-        return self.op_code[1] == 'f'
-
     @property
     def sew(self):
         """Return the selected element width."""
@@ -87,68 +75,52 @@
     @sew.setter
     def sew(self, value):
         """Set the selected element width."""
-        if self.is_floating():
-            if not (value == 32):
-                raise ValueError("Invalid SEW")
         if not value in (8, 16, 32):
             raise ValueError("Invalid SEW")
         self._sew = value
 
     def is_widening(self):
         """Check if a particular op_code is a widening type."""
-        if self.is_floating():
-            raise ValueError("Widening is not supported with this template for floating point values")
         return self.op_code[1] == 'w'
 
     def is_narrowing(self):
         """Check if a particular op_code is a narrowing type."""
-        if self.is_floating():
-            raise ValueError("Narrowing is not supported with this template for floating point values")
         return self.op_code[1] == 'n'
 
     def is_destination_mask_register(self):
         """Check if a particular op_code has a mask output."""
-        if self.is_floating():
-            return False
         int_comparison_ops = ('vmseq', 'vmsne', 'vmsltu', 'vmsleu', 'vmsle', 'vmsgtu', 'vmsgt')
         return self.op_code in int_comparison_ops
 
     def is_unsigned(self):
         """Check if a particular op_code is a unsigned type."""
-        if self.is_floating():
-            raise ValueError("Invalid unsigned type op code")
         return self.op_code[-1] == 'u'
 
     def get_sews(self):
         """Given an op_code return a list of valid element widths."""
-        if self.is_floating():
-            return [32]
-
         if self.is_widening() or self.is_narrowing():
             return [8, 16]
         return [8, 16, 32]
 
     def get_sew_sizes(self):
         """Return size of types."""
-        """imm is not used for floating point op codes."""
         dest_sew = self.sew
         src2_sew = self.sew
         src1_sew = self.sew
         imm_sew = self.sew
-        if (not self.is_floating()) and self.is_narrowing():
+        if self.is_narrowing():
             src2_sew = self.sew * 2
-        elif (not self.is_floating()) and self.is_widening():
+        elif self.is_widening():
             dest_sew = self.sew * 2
         return dest_sew, src2_sew, src1_sew, imm_sew
 
     def get_var_types(self):
         """Return types for an op_code and element width."""
-        """imm_type won't be used for floating point values."""
         VarTypes = collections.namedtuple(
             "VarTypes",
             ('dest_type', 'src2_type', 'src1_type', 'imm_type'))
-        type_fmt = "%sfloat%d_t" if self.is_floating() else "%sint%d_t"
-        sign_type  = "u" if (not self.is_floating()) and (self.is_unsigned() or self.force_unsigned) else ""
+        type_fmt = "%sint%d_t"
+        sign_type  = "u" if self.is_unsigned() or self.force_unsigned  else ""
         dest_sew, src2_sew, src1_sew, imm_sew = self.get_sew_sizes()
         dest_type = type_fmt % (sign_type, dest_sew)
         src1_type = type_fmt % (sign_type, src1_sew)
@@ -160,18 +132,16 @@
     def get_mnemonic(self, operand_type):
         """Generate the correct mnemonic given a opcode and operand type."""
         operand_width = self.OperandWidth.STANDARD
-        if (not self.is_floating()) and self.is_narrowing():
+        if self.is_narrowing():
             operand_width = self.OperandWidth.NARROWING
-        elif (not self.is_floating()) and self.is_widening():
+        elif self.is_widening():
             operand_width = self.OperandWidth.WIDENING
-        if self.is_floating() and operand_type == self.OperandType.SCALAR:
-            operand_type = self.OperandType.FLOATSCALAR
         op_suffix = self.mnemonic_suffix[operand_type][operand_width]
         return "%s.%s" % (self.op_code, op_suffix)
 
     def get_lmuls(self):
         """Given an op_code return an iterable of valid lmuls."""
-        if (not self.is_floating()) and (self.is_widening() or self.is_narrowing()):
+        if self.is_widening() or self.is_narrowing():
             return [1, 2, 4]
         return [1, 2, 4, 8]
 
@@ -184,20 +154,16 @@
     def get_softrvv_template_data_type(self):
         """Return types """
         var_types = self.get_var_types()
-        if (not self.is_floating()) and (self.is_narrowing() or self.is_widening()):
+        if self.is_narrowing() or self.is_widening():
             return "%s, %s" % (var_types.dest_type, var_types.src2_type)
         return var_types.src1_type
 
     def get_ref_opcode(self):
         """Return the name of the reference code in the softrvv library."""
-        if self.is_floating():
-            return self.op_code
         return self.op_code[:-1] if self.is_unsigned() else self.op_code
 
     def get_imms(self):
         """Return a list of valid immediate values for a op code."""
-        if self.is_floating():
-            raise ValueError("imm is not available.")
         if self.op_code in ['vsll', 'vsrl', 'vsra', 'vnsrl', 'vnsra']:
             # Left and right shift immediates must be [0,31]
             return np.linspace(0, 31, 8, dtype=np.int32)
@@ -206,8 +172,6 @@
 
     def get_np_dest_type(self):
         """Return numpy type for destination."""
-        if self.is_floating():
-            return self.float_np_types[self.sew]
         if self.force_unsigned:
             types = self.unsigned_np_types
         else:
@@ -218,8 +182,6 @@
 
     def get_np_src1_type(self):
         """Return numpy type for src1."""
-        if self.is_floating():
-            return self.float_np_types[self.sew]
         if self.force_unsigned:
             types = self.unsigned_np_types
         else:
@@ -228,8 +190,6 @@
 
     def get_np_src2_type(self):
         """Return numpy type for src2."""
-        if self.is_floating():
-            return self.float_np_types[self.sew]
         if self.force_unsigned:
             types = self.unsigned_np_types
         else:
@@ -242,28 +202,12 @@
         """Return test inputs."""
         src1_np_type = self.get_np_src1_type()
         src2_np_type = self.get_np_src2_type()
-        src2_np_type = self.get_np_src2_type()
-        """Return test inputs for floating points."""
-        if self.is_floating():
-          type_info = np.finfo(src1_np_type)
-          src1_data = np.random.uniform(
-              type_info.min/2.0, type_info.max/2.0, n).astype(src1_np_type)
-          rs1 = self.get_np_src1_type()(np.random.uniform(
-              type_info.min/2.0, type_info.max/2.0))
-          type_info = np.finfo(src2_np_type)
-          src2_data = np.random.uniform(
-              type_info.min/2.0, type_info.max/2.0, n).astype(src2_np_type)
-          if not allow_zero:
-              src2_data[src2_data==0] = 1
-              rs1 = 1.0 if rs1 == 0.0 else rs1
-          return src2_data, src1_data, rs1
-
-        """Return test inputs for integers."""
         type_info = np.iinfo(src1_np_type)
         src1_data =  np.random.randint(
             type_info.min, type_info.max, n).astype(src1_np_type)
         rs1 = self.get_np_src1_type()(np.random.randint(
             type_info.min, type_info.max))
+        src2_np_type = self.get_np_src2_type()
         type_info = np.iinfo(src2_np_type)
         src2_data = np.random.randint(
             type_info.min, type_info.max, n).astype(src2_np_type)
@@ -273,13 +217,12 @@
         return src2_data, src1_data, rs1
 
     def pack_dest_mask(self, values):
-        """Pack values into a single destination register."""
-        dest_type = self.get_np_dest_type()
-        return np.packbits(dest_type(values), bitorder='little')
+            """Pack values into a single destination register."""
+            dest_type = self.get_np_dest_type()
+            return np.packbits(dest_type(values), bitorder='little')
 
 def cast_to_unsigned(arr):
     """Cast a signed array to an unsigned array."""
-    """This should not be called with floating point values."""
     udtypes = {np.int8:np.uint8,
                np.int16:np.uint16,
                np.int32:np.uint32,
diff --git a/softrvv/include/softrvv.h b/softrvv/include/softrvv.h
index 1046aba..d82e7a0 100644
--- a/softrvv/include/softrvv.h
+++ b/softrvv/include/softrvv.h
@@ -31,9 +31,6 @@
 #include "softrvv_vwsub.h"
 #include "softrvv_vxor.h"
 
-#include "softrvv_vfadd.h"
-#include "softrvv_vfsub.h"
-
 namespace softrvv {
 
 const uint32_t MSTATUS_VS_FS_ENABLE_BIT =
diff --git a/softrvv/include/softrvv_vfadd.h b/softrvv/include/softrvv_vfadd.h
deleted file mode 100644
index 86009c8..0000000
--- a/softrvv/include/softrvv_vfadd.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#ifndef SOFTRVV_VFADD_H
-#define SOFTRVV_VFADD_H
-
-#include <stddef.h>
-
-namespace softrvv {
-
-template <typename T>
-void vfadd_vf(T *dest, T *src1, const T *src2, int32_t avl) {
-  for (int32_t idx = 0; idx < avl; idx++) {
-    dest[idx] = src1[idx] + *src2;
-  }
-}
-
-template <typename T>
-void vfadd_vv(T *dest, T *src1, T *src2, int32_t avl) {
-  for (int32_t idx = 0; idx < avl; idx++) {
-    dest[idx] = src1[idx] + src2[idx];
-  }
-}
-
-}  // namespace softrvv
-
-#endif  // SOFTRVV_VFADD_H
diff --git a/softrvv/include/softrvv_vfsub.h b/softrvv/include/softrvv_vfsub.h
deleted file mode 100644
index eea2f26..0000000
--- a/softrvv/include/softrvv_vfsub.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef SOFTRVV_VFSUB_H
-#define SOFTRVV_VFSUB_H
-
-#include <stddef.h>
-
-namespace softrvv {
-
-template <typename T>
-void vfsub_vf(T *dest, T *src1, const T *src2, int32_t avl) {
-  for (int idx = 0; idx < avl; idx++) {
-    dest[idx] = src1[idx] - *src2;
-  }
-}
-
-template <typename T>
-void vfsub_vv(T *dest, T *src1, T *src2, int32_t avl) {
-  for (int32_t idx = 0; idx < avl; idx++) {
-    dest[idx] = src1[idx] - src2[idx];
-  }
-}
-
-template <typename T>
-void vfrsub_vx(T *dest, T *src1, const T *src2, int32_t avl) {
-  for (int32_t idx = 0; idx < avl; idx++) {
-    dest[idx] = *src2 - src1[idx];
-  }
-}
-
-}  // namespace softrvv
-
-#endif  // SOFTRVV_VFSUB_H
diff --git a/softrvv/tests/CMakeLists.txt b/softrvv/tests/CMakeLists.txt
index 289f74e..62cbc9a 100644
--- a/softrvv/tests/CMakeLists.txt
+++ b/softrvv/tests/CMakeLists.txt
@@ -100,24 +100,6 @@
 
 softrvv_vec_cc_generated_test(
   NAME
-    vfadd
-  TEMPLATE
-    softrvv_vfadd_test.tpl.cpp
-  LINKOPTS
-   -Xlinker --defsym=__itcm_length__=128K
-)
-
-softrvv_vec_cc_generated_test(
-  NAME
-    vfsub
-  TEMPLATE
-    softrvv_vfsub_test.tpl.cpp
-  LINKOPTS
-   -Xlinker --defsym=__itcm_length__=128K
-)
-
-softrvv_vec_cc_generated_test(
-  NAME
     vadd
   TEMPLATE
     softrvv_vadd_test.tpl.cpp
diff --git a/softrvv/tests/templates/base.tpl.cpp b/softrvv/tests/templates/base.tpl.cpp
index 9fc3bfa..586cfff 100644
--- a/softrvv/tests/templates/base.tpl.cpp
+++ b/softrvv/tests/templates/base.tpl.cpp
@@ -1,3 +1,16 @@
+<%!
+import numpy  as np
+
+def get_test_inputs(dtype, N, allow_zero=True):
+    ii32 = np.iinfo(dtype)
+    src1_data =  np.random.randint(ii32.min, ii32.max, N).astype(dtype)
+    src2_data = np.random.randint(ii32.min, ii32.max, N).astype(dtype)
+    rs1 = dtype(np.random.randint(ii32.min, ii32.max))
+    if not allow_zero:
+        src2_data[src2_data==0] = 1
+        rs1 = 1 if rs1 == 0 else rs1
+    return src1_data, src2_data, rs1
+%>
 /* File is auto-generated. */
 #include <riscv_vector.h>
 #include <springbok.h>
diff --git a/softrvv/tests/templates/opivf_test.tpl.cpp b/softrvv/tests/templates/opivf_test.tpl.cpp
deleted file mode 100644
index 87c04c1..0000000
--- a/softrvv/tests/templates/opivf_test.tpl.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-<%!
-import vec_test_helpers
-%>\
-<%def name="test_opivf(template_helper, src2, rs1, ref_vf)">
-<%
-src2 = vec_test_helpers.to_carr_str(src2)
-ref_vf = vec_test_helpers.to_carr_str(ref_vf)
-%>\
-namespace softrvv_${template_helper.op_code}_vf_test {
-namespace {
-${insert_variable_init(template_helper, src2, rs1, ref_vf)}
-
-class SoftRvv${template_helper.op_code.capitalize()}Test : public ::testing::Test {
- protected:
-  void SetUp() override { memset(dest, 0, sizeof(dest)); }
-};
-${insert_test(template_helper)}\
-}  // namespace
-}  // namespace softrvv_${op}_vf_test\
-</%def>\
-
-<%def name="insert_variable_init(template_helper, src2, rs1, ref_vf)">
-<%
-  var_types = template_helper.get_var_types()
-%>\
-${var_types.src2_type} src2[] = {${src2}};
-${var_types.imm_type} rs1 = ${rs1};
-const int kAVL = sizeof(src2)/sizeof(src2[0]);
-${var_types.dest_type} dest[kAVL];
-
-${var_types.dest_type} ref_vf[kAVL] = {${ref_vf}};
-</%def>\
-
-<%def name="insert_test(template_helper)">
-<%
-var_types = template_helper.get_var_types()
-datatypes = template_helper.get_softrvv_template_data_type()
-%>\
-
-TEST_F(SoftRvv${template_helper.op_code.capitalize()}Test, VF) {
-  softrvv::${template_helper.op_code}_vf<${datatypes}>(dest, src2, &rs1, kAVL);\
-${insert_check(template_helper, var_types.dest_type, "ref_vf")}\
-}
-</%def>\
-
-<%def name="insert_check(template_helper, dest_type, ref_var)">
-% if template_helper.is_destination_mask_register():
-  assert_vec_mask_eq<${dest_type}>(kAVL, dest, ${ref_var});
-% else:
-  assert_vec_elem_eq<${dest_type}>(kAVL, dest, ${ref_var});
-% endif
-</%def>\
diff --git a/softrvv/tests/templates/opivv_test.tpl.cpp b/softrvv/tests/templates/opivv_test.tpl.cpp
deleted file mode 100644
index 08bd2e7..0000000
--- a/softrvv/tests/templates/opivv_test.tpl.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-<%!
-import vec_test_helpers
-%>\
-<%def name="test_opivv(template_helper, src2, src1,  ref_vv)">
-<%
-src1 = vec_test_helpers.to_carr_str(src1)
-src2 = vec_test_helpers.to_carr_str(src2)
-ref_vv = vec_test_helpers.to_carr_str(ref_vv)
-%>\
-namespace softrvv_${template_helper.op_code}_vv_test {
-namespace {
-${insert_variable_init(template_helper, src2, src1, ref_vv)}
-
-class SoftRvv${template_helper.op_code.capitalize()}Test : public ::testing::Test {
- protected:
-  void SetUp() override { memset(dest, 0, sizeof(dest)); }
-};
-${insert_test(template_helper)}\
-}  // namespace
-}  // namespace softrvv_${op}_vv_test\
-</%def>\
-
-<%def name="insert_variable_init(template_helper, src2, src1, ref_vv)">
-<%
-  var_types = template_helper.get_var_types()
-%>\
-${var_types.src1_type} src1[] = {${src1}};
-${var_types.src2_type} src2[] = {${src2}};
-const int kAVL = sizeof(src1)/sizeof(src1[0]);
-${var_types.dest_type} dest[kAVL];
-
-${var_types.dest_type} ref_vv[kAVL] = {${ref_vv}};
-</%def>\
-
-<%def name="insert_test(template_helper)">
-<%
-var_types = template_helper.get_var_types()
-datatypes = template_helper.get_softrvv_template_data_type()
-%>\
-TEST_F(SoftRvv${template_helper.op_code.capitalize()}Test, VV) {
-  softrvv::${template_helper.op_code}_vv<${datatypes}>(dest, src2, src1, kAVL);\
-${insert_check(template_helper, var_types.dest_type, "ref_vv")}\
-}
-
-</%def>\
-
-<%def name="insert_check(template_helper, dest_type, ref_var)">
-% if template_helper.is_destination_mask_register():
-  assert_vec_mask_eq<${dest_type}>(kAVL, dest, ${ref_var});
-% else:
-  assert_vec_elem_eq<${dest_type}>(kAVL, dest, ${ref_var});
-% endif
-</%def>\
diff --git a/softrvv/tests/templates/softrvv_vfadd_test.tpl.cpp b/softrvv/tests/templates/softrvv_vfadd_test.tpl.cpp
deleted file mode 100644
index ec8695b..0000000
--- a/softrvv/tests/templates/softrvv_vfadd_test.tpl.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-<%inherit file="base.tpl.cpp"/>\
-<%namespace name="tests_vv" file="opivv_test.tpl.cpp"/>\
-<%namespace name="tests_vf" file="opivf_test.tpl.cpp"/>\
-<%
-import numpy as np
-import vec_test_helpers
-template_helper = vec_test_helpers.VecTemplateHelper(op, 32)
-src2, src1, rs1 = template_helper.get_test_inputs(n=5)
-ref_vv = src2 + src1
-ref_vf = src2 + rs1
-%>\
-${tests_vv.test_opivv(template_helper, src2, src1, ref_vv)}
-${tests_vf.test_opivf(template_helper, src2, rs1, ref_vf)}
-
diff --git a/softrvv/tests/templates/softrvv_vfsub_test.tpl.cpp b/softrvv/tests/templates/softrvv_vfsub_test.tpl.cpp
deleted file mode 100644
index f27fd3a..0000000
--- a/softrvv/tests/templates/softrvv_vfsub_test.tpl.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-<%inherit file="base.tpl.cpp"/>\
-<%namespace name="tests_vv" file="opivv_test.tpl.cpp"/>
-<%namespace name="tests_vf" file="opivf_test.tpl.cpp"/>
-<%
-import numpy as np
-import vec_test_helpers
-template_helper = vec_test_helpers.VecTemplateHelper(op, 32)
-src2, src1, rs1 = template_helper.get_test_inputs(n=5)
-ref_vv = src2 - src1
-ref_vf = src2 - rs1
-%>\
-${tests_vv.test_opivv(template_helper, src2, src1, ref_vv)}
-${tests_vf.test_opivf(template_helper, src2, rs1, ref_vf)}
diff --git a/test_v_helpers/include/test_v_helpers.h b/test_v_helpers/include/test_v_helpers.h
index 66760c0..ba28e43 100644
--- a/test_v_helpers/include/test_v_helpers.h
+++ b/test_v_helpers/include/test_v_helpers.h
@@ -8,20 +8,6 @@
 
 #include "pw_unit_test/framework.h"
 
-#ifdef __cplusplus
-
-using float32_t = float;
-using float64_t = double;
-using float128_t = long double;
-
-#else
-
-typedef float  float32_t;
-typedef double float64_t;
-typedef long double float128_t;
-
-#endif // __cplusplus
-
 namespace test_v_helpers {
 
 const int LMUL_MAX = 8;
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index e2f55ff..2230dd1 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -1,12 +1,3 @@
-# vec_cc_generated_test(
-#   NAME
-#     vfadd
-#   TEMPLATE
-#     opivv_test.tpl.cpp
-#   LINKOPTS
-#    -Xlinker --defsym=__itcm_length__=128K
-# )
-
 vec_cc_generated_test(
   NAME
     vsub
@@ -400,12 +391,3 @@
   LINKOPTS
     -Xlinker --defsym=__itcm_length__=128K
 )
-
-vec_cc_test(
-  NAME
-    vfadd_test
-  SRCS
-    vector_vfadd_test.cpp
-  LINKOPTS
-   -Xlinker --defsym=__itcm_length__=128K
-)
\ No newline at end of file
diff --git a/tests/vector_vfadd_test.cpp b/tests/vector_vfadd_test.cpp
deleted file mode 100644
index 9ec1eac..0000000
--- a/tests/vector_vfadd_test.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-#include <limits.h>
-#include <riscv_vector.h>
-#include <softrvv.h>
-#include <springbok.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <stdint.h> 
-#include <bit>
-#include <tuple>
-
-#include "pw_unit_test/framework.h"
-#include "test_v_helpers.h"
-
-#ifdef __cplusplus
-
-using float32_t = float;
-using float64_t = double;
-using float128_t = long double;
-
-#else
-
-typedef float  float32_t;
-typedef double float64_t;
-typedef long double float128_t;
-
-#endif // __cplusplus
-
-namespace vfadd_vv_test
-{
-    namespace
-    {
-        using namespace test_v_helpers;
-        
-        float src_vector_1[MAXVL_BYTES];
-        float src_vector_2[MAXVL_BYTES];
-        float dest_vector[MAXVL_BYTES];
-        float ref_dest_vector[MAXVL_BYTES];
-        
-        class VfaddTest : public ::testing::Test {
-            protected:
-                void SetUp() override { zero_vector_registers(); }
-                void TearDown() override { zero_vector_registers(); }
-        };
-        
-        TEST_F(VfaddTest, vfadd_vv32m1) {
-            for (int i = 0; i < AVL_COUNT; i++) {
-                int32_t avl = AVLS[i];
-                int vlmax;
-                int vl;
-
-                /* For non narrowing instructions all vectors have same type*/
-                std::tie(vlmax, vl) = vector_test_setup<int32_t>(
-                    VLMUL::LMUL_M1, avl,
-                    {dest_vector, ref_dest_vector, src_vector_1});
-                    
-                if (avl > vlmax) {
-                     continue;
-                }
-    
-                float *ptr_vec_1 = reinterpret_cast<float *>(src_vector_1);
-                float *ptr_vec_2 = reinterpret_cast<float *>(src_vector_2);
-                float *ptr_dest_vec = reinterpret_cast<float *>(dest_vector);
-                float *ptr_ref_dest_vec = reinterpret_cast<float *>(ref_dest_vector);
-
-                // set up values to test up to index of the AVL
-                fill_random_vector<float>(ptr_vec_1, avl);
-                fill_random_vector<float>(ptr_vec_2, avl);
-                memset(dest_vector, 0, MAXVL_BYTES);
-                memset(ref_dest_vector, 0, MAXVL_BYTES);
-
-                // Generate reference vector
-                softrvv::vfadd_vv<float>(ptr_ref_dest_vec, ptr_vec_2, ptr_vec_1, avl);
-                // Load vector registers
-                __asm__ volatile("vle32.v v8, (%0)" : : "r"(ptr_vec_1));
-                __asm__ volatile("vle32.v v16, (%0)" : : "r"(ptr_vec_2));
-
-                // Run target instruction
-                __asm__ volatile("vfadd.vv v24, v16, v8");
-
-                // Store result vector register
-                __asm__ volatile("vse32.v v24, (%0)" : : "r"(ptr_dest_vec));
-                // Check vector elements
-                assert_vec_elem_eq<float>(vlmax, dest_vector, ref_dest_vector);
-            }
-        }
-    }
-}