Rename verify_range to verify_rms_range

test/ref/concat.cpp

@@ -50,11 +50,11 @@ TEST_CASE(concat_test_1)
     std::vector<int> gold = {0, 1, 2, 3, 4, 10, 5, 6, 7, 8, 9, 20};
     std::vector<int> results_vector(2 * 6);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
-    EXPECT(migraphx::verify::verify_range(result.get_shape().lens(),
-                                          std::vector<std::size_t>({2, 6})));
-    EXPECT(migraphx::verify::verify_range(result.get_shape().strides(),
-                                          std::vector<std::size_t>({6, 1})));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().lens(),
+                                              std::vector<std::size_t>({2, 6})));
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().strides(),
+                                              std::vector<std::size_t>({6, 1})));
 }
 
 TEST_CASE(concat_test_2)
@@ -77,11 +77,11 @@ TEST_CASE(concat_test_2)
     std::vector<int> gold = {0, 1, 2, 3, 4, 10, 5, 6, 7, 8, 9, 20};
     std::vector<int> results_vector(2 * 6);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
-    EXPECT(migraphx::verify::verify_range(result.get_shape().lens(),
-                                          std::vector<std::size_t>({2, 6})));
-    EXPECT(migraphx::verify::verify_range(result.get_shape().strides(),
-                                          std::vector<std::size_t>({6, 1})));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().lens(),
+                                              std::vector<std::size_t>({2, 6})));
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().strides(),
+                                              std::vector<std::size_t>({6, 1})));
 }
 
 TEST_CASE(concat_test_3)
@@ -104,11 +104,11 @@ TEST_CASE(concat_test_3)
     std::vector<int> gold = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
     std::vector<int> results_vector(6 * 2);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
-    EXPECT(migraphx::verify::verify_range(result.get_shape().lens(),
-                                          std::vector<std::size_t>({6, 2})));
-    EXPECT(migraphx::verify::verify_range(result.get_shape().strides(),
-                                          std::vector<std::size_t>({2, 1})));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().lens(),
+                                              std::vector<std::size_t>({6, 2})));
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().strides(),
+                                              std::vector<std::size_t>({2, 1})));
 }
 
 TEST_CASE(concat_test_4)
@@ -131,11 +131,11 @@ TEST_CASE(concat_test_4)
     std::vector<int> gold = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
     std::vector<int> results_vector(6 * 2);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
-    EXPECT(migraphx::verify::verify_range(result.get_shape().lens(),
-                                          std::vector<std::size_t>({6, 2})));
-    EXPECT(migraphx::verify::verify_range(result.get_shape().strides(),
-                                          std::vector<std::size_t>({2, 1})));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().lens(),
+                                              std::vector<std::size_t>({6, 2})));
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().strides(),
+                                              std::vector<std::size_t>({2, 1})));
 }
 
 TEST_CASE(concat_dyn_test)
@@ -169,7 +169,7 @@ TEST_CASE(concat_dyn_test)
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
 
     std::vector<float> gold = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
-    EXPECT(migraphx::verify::verify_range(result.get_shape().lens(),
-                                          std::vector<std::size_t>({6, 2})));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().lens(),
+                                              std::vector<std::size_t>({6, 2})));
 }

test/ref/contiguous.cpp

@@ -50,7 +50,7 @@ TEST_CASE(contiguous_test)
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
 
     std::vector<float> gold = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(contiguous_param_test)
@@ -74,7 +74,7 @@ TEST_CASE(contiguous_param_test)
     std::vector<float> results_vector(12);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(contiguous_dyn_test)
@@ -100,5 +100,5 @@ TEST_CASE(contiguous_dyn_test)
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
 
     std::vector<float> gold = {0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/convolution.cpp

@@ -103,7 +103,7 @@ TEST_CASE(conv_dyn_batch_test)
                                0.44276932,
                                -0.16138598,
                                0.79344082};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(conv_dyn_img_shape_test)
@@ -149,7 +149,7 @@ TEST_CASE(conv_dyn_img_shape_test)
 
     std::vector<float> gold = {6.1329393, 4.3199925, 5.448438, 3.8497565};
 
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 
     a = {0.95600171, 0.20768181, 0.82844489, 0.14928212, 0.51280462, 0.1359196,  0.68903648,
          0.84174772, 0.425509,   0.956926,   0.82533291, 0.33821531, 0.57576055, 0.75330186,
@@ -191,7 +191,7 @@ TEST_CASE(conv_dyn_img_shape_test)
     result = p.eval(params1).back();
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(conv_dyn_weights_shape_test)
@@ -251,7 +251,7 @@ TEST_CASE(conv_dyn_weights_shape_test)
                                2.1917608,
                                1.6797699};
 
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 
     c    = {0.98411968, 0.2899219,  0.44638833, 0.30390816, 0.03989896, 0.2445332,  0.32700131,
             0.57517075, 0.06956476, 0.93079306, 0.19882314, 0.52940601, 0.35624753, 0.35938406,
@@ -267,7 +267,7 @@ TEST_CASE(conv_dyn_weights_shape_test)
     result = p.eval(params1).back();
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(conv_dyn_img_same_upper_test)
@@ -336,7 +336,7 @@ TEST_CASE(conv_dyn_img_same_upper_test)
                                4.117671,
                                3.5187216,
                                2.3236327};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(conv_dyn_kernel_same_upper_test)
@@ -409,7 +409,7 @@ TEST_CASE(conv_dyn_kernel_same_upper_test)
                                0.9225286,
                                1.43048,
                                0.74341124};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(conv_dyn_kernel_same_lower_test)
@@ -483,7 +483,7 @@ TEST_CASE(conv_dyn_kernel_same_lower_test)
                                2.50734,
                                2.7736917};
 
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(conv2d_padding_stride_test)
@@ -546,7 +546,7 @@ TEST_CASE(conv2d_padding_stride_test)
                                -0.16138598,
                                0.79344082};
 
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(conv2d_padding_test)
@@ -603,7 +603,7 @@ TEST_CASE(conv2d_padding_test)
         -0.02471633, -0.58163726, -0.02211772, -0.42014724, 0.77525634,  0.504951,    -0.20537445,
         -0.20369984, -0.83037728, -1.40423918, -0.46160448, -0.22944322, 0.36074194,  0.49579027,
         0.46527559};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(conv2d_test)
@@ -668,7 +668,7 @@ TEST_CASE(conv2d_test)
                                0.71606487,
                                -0.55201721,
                                -0.46427044};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(conv3d_test)
@@ -736,5 +736,5 @@ TEST_CASE(conv3d_test)
                                0.71606487,
                                -0.55201721,
                                -0.46427044};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/convolution_backwards.cpp

@@ -52,7 +52,7 @@ TEST_CASE(convolution_backwards_1d)
 
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(convolution_backwards_2d)
@@ -75,7 +75,7 @@ TEST_CASE(convolution_backwards_2d)
 
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(convolution_backwards_3d)
@@ -113,7 +113,7 @@ TEST_CASE(convolution_backwards_3d)
 
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(convolution_backwards_padding1)
@@ -139,7 +139,7 @@ TEST_CASE(convolution_backwards_padding1)
 
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(convolution_backwards_padding2)
@@ -165,7 +165,7 @@ TEST_CASE(convolution_backwards_padding2)
 
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(convolution_backwards_2stride)
@@ -192,7 +192,7 @@ TEST_CASE(convolution_backwards_2stride)
 
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(convolution_backwards_2dilation)
@@ -219,7 +219,7 @@ TEST_CASE(convolution_backwards_2dilation)
 
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(convolution_backwards_dyn_batch1)
@@ -247,7 +247,7 @@ TEST_CASE(convolution_backwards_dyn_batch1)
                             27, 15, 9, 20, 33, 24, 13, 6,  13, 21, 15, 8};
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(convolution_backwards_dyn_batch2)
@@ -288,5 +288,5 @@ TEST_CASE(convolution_backwards_dyn_batch2)
 
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/cos.cpp

@@ -45,7 +45,7 @@ TEST_CASE(cos_test)
     std::vector<float> gold = data;
     std::transform(
         gold.begin(), gold.end(), gold.begin(), [](float n) -> float { return cosf(n); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(cos_dyn_test)
@@ -68,5 +68,5 @@ TEST_CASE(cos_dyn_test)
     std::vector<float> gold = input_data;
     std::transform(
         gold.begin(), gold.end(), gold.begin(), [](float n) -> float { return cosf(n); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/cosh.cpp

@@ -45,7 +45,7 @@ TEST_CASE(cosh_test)
     std::vector<float> gold = data;
     std::transform(
         gold.begin(), gold.end(), gold.begin(), [](float n) -> float { return coshf(n); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(cosh_dyn_test)
@@ -68,5 +68,5 @@ TEST_CASE(cosh_dyn_test)
     std::vector<float> gold = input_data;
     std::transform(
         gold.begin(), gold.end(), gold.begin(), [](float n) -> float { return coshf(n); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/dimensions_of.cpp

@@ -47,7 +47,7 @@ TEST_CASE(dimensions_of_test0)
     std::vector<int64_t> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<int64_t> gold = {2, 3, 4};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(dimensions_of_test1)
@@ -67,5 +67,5 @@ TEST_CASE(dimensions_of_test1)
     std::vector<int64_t> results_vector(2);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<int64_t> gold = {4, 4};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/div.cpp

@@ -46,7 +46,7 @@ TEST_CASE(div_test)
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold(data1.size());
     std::transform(data1.begin(), data1.end(), data2.begin(), gold.begin(), std::divides<float>());
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(div_dyn_test)
@@ -72,5 +72,5 @@ TEST_CASE(div_dyn_test)
     std::vector<float> gold(x_data.size());
     std::transform(
         x_data.begin(), x_data.end(), y_data.begin(), gold.begin(), std::divides<float>());
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/dot_op.cpp

@@ -187,7 +187,7 @@ TEST_CASE(dot_3D_test)
                                0.40245487,
                                1.80182751};
 
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_3D_C_test0)
@@ -263,7 +263,7 @@ TEST_CASE(dot_3D_C_test0)
                                0.40245487,
                                1.80182751};
 
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_3D_C_test1)
@@ -322,7 +322,7 @@ TEST_CASE(dot_3D_C_test1)
                                -0.95536130,
                                2.27996211};
 
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_4D_test1)
@@ -361,7 +361,7 @@ TEST_CASE(dot_4D_test1)
                                -0.95467340, -1.74728628, -2.42477030, 0.76262372,  0.15539164,
                                3.32281958,  0.96769613,  0.43727545,  2.43019906};
 
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_4D_alpha_beta_test)
@@ -415,7 +415,7 @@ TEST_CASE(dot_4D_alpha_beta_test)
                                -0.17183724, 0.10858734, 0.39406289,  0.04662959,  1.07979824,
                                0.40355016,  0.52410648, -0.31728447, 1.09550845};
 
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_4D_alpha_beta_C_test)
@@ -467,7 +467,7 @@ TEST_CASE(dot_4D_alpha_beta_C_test)
                                -0.17183724, 0.10858734, 0.39406289,  0.04662959,  1.07979824,
                                0.40355016,  0.52410648, -0.31728447, 1.09550845};
 
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_2D_C_test0)
@@ -523,7 +523,7 @@ TEST_CASE(dot_2D_C_test0)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_vv_inner_product_1)
@@ -559,7 +559,7 @@ TEST_CASE(dot_vv_inner_product_1)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_vv_inner_product_2)
@@ -597,7 +597,7 @@ TEST_CASE(dot_vv_inner_product_2)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_vm_1)
@@ -632,7 +632,7 @@ TEST_CASE(dot_vm_1)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_vm_2)
@@ -669,7 +669,7 @@ TEST_CASE(dot_vm_2)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_vm_3)
@@ -715,7 +715,7 @@ TEST_CASE(dot_vm_3)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_vm_4)
@@ -762,7 +762,7 @@ TEST_CASE(dot_vm_4)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_mv_1)
@@ -799,7 +799,7 @@ TEST_CASE(dot_mv_1)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_mv_2)
@@ -838,7 +838,7 @@ TEST_CASE(dot_mv_2)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_mv_3)
@@ -882,7 +882,7 @@ TEST_CASE(dot_mv_3)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_mm1_1)
@@ -933,7 +933,7 @@ TEST_CASE(dot_mm1_1)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_mm1_2)
@@ -986,7 +986,7 @@ TEST_CASE(dot_mm1_2)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_mm2_1)
@@ -1028,7 +1028,7 @@ TEST_CASE(dot_mm2_1)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_mm2_2)
@@ -1071,7 +1071,7 @@ TEST_CASE(dot_mm2_2)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_mm2_3)
@@ -1120,7 +1120,7 @@ TEST_CASE(dot_mm2_3)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_mm2_4)
@@ -1166,7 +1166,7 @@ TEST_CASE(dot_mm2_4)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(dot_dyn_2D_test)
@@ -1218,7 +1218,7 @@ TEST_CASE(dot_dyn_2D_test)
                                -1.29885596e+00,
                                2.16294914e+00,
                                -1.48101497e-01};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(dot_dyn_4D_test)
@@ -1272,7 +1272,7 @@ TEST_CASE(dot_dyn_4D_test)
                                -1.29885596e+00,
                                2.16294914e+00,
                                -1.48101497e-01};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(quant_dot_2args_multi4_1)
@@ -1299,7 +1299,7 @@ TEST_CASE(quant_dot_2args_multi4_1)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(quant_dot_2args_multi4_2)
@@ -1327,7 +1327,7 @@ TEST_CASE(quant_dot_2args_multi4_2)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(quant_dot_2args_multi4_3)
@@ -1355,7 +1355,7 @@ TEST_CASE(quant_dot_2args_multi4_3)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(quant_dot_2args_multi4_4)
@@ -1384,7 +1384,7 @@ TEST_CASE(quant_dot_2args_multi4_4)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(quant_dot_2args_general_1)
@@ -1409,7 +1409,7 @@ TEST_CASE(quant_dot_2args_general_1)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(quant_dot_2args_general_2)
@@ -1436,7 +1436,7 @@ TEST_CASE(quant_dot_2args_general_2)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(quant_dot_2args_general_3)
@@ -1464,7 +1464,7 @@ TEST_CASE(quant_dot_2args_general_3)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(quant_dot_2args_general_4)
@@ -1492,7 +1492,7 @@ TEST_CASE(quant_dot_2args_general_4)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(quant_dot_3args_general_1)
@@ -1522,7 +1522,7 @@ TEST_CASE(quant_dot_3args_general_1)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(quant_dot_3args_general_2)
@@ -1550,7 +1550,7 @@ TEST_CASE(quant_dot_3args_general_2)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(quant_dot_3args_general_3)
@@ -1581,7 +1581,7 @@ TEST_CASE(quant_dot_3args_general_3)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(quant_dot_3args_general_4)
@@ -1612,7 +1612,7 @@ TEST_CASE(quant_dot_3args_general_4)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(quant_dot_3args_general_5)
@@ -1644,7 +1644,7 @@ TEST_CASE(quant_dot_3args_general_5)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(quant_dot_3args_batch_1)
@@ -1678,7 +1678,7 @@ TEST_CASE(quant_dot_3args_batch_1)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }
 
 TEST_CASE(quant_dot_3args_batch_2)
@@ -1717,5 +1717,5 @@ TEST_CASE(quant_dot_3args_batch_2)
     auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(m, gold));
+    EXPECT(migraphx::verify::verify_rms_range(m, gold));
 }

test/ref/elu.cpp

@@ -45,7 +45,7 @@ TEST_CASE(elu_test)
     std::vector<float> results_vector(4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{elu(alpha, -1), elu(alpha, 2), elu(alpha, -3), elu(alpha, 4)};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(elu_dyn_test)
@@ -67,5 +67,5 @@ TEST_CASE(elu_dyn_test)
     std::vector<float> results_vector(4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{elu(alpha, -1), elu(alpha, 2), elu(alpha, -3), elu(alpha, 4)};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/erf.cpp

@@ -45,7 +45,7 @@ TEST_CASE(erf_test)
     std::vector<float> gold = data;
     std::transform(
         gold.begin(), gold.end(), gold.begin(), [](float n) -> float { return erff(n); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(erf_dyn_test)
@@ -68,5 +68,5 @@ TEST_CASE(erf_dyn_test)
     std::vector<float> gold = input_data;
     std::transform(
         gold.begin(), gold.end(), gold.begin(), [](float n) -> float { return erff(n); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/exp.cpp

@@ -45,7 +45,7 @@ TEST_CASE(exp_test)
     std::vector<float> gold = data;
     std::transform(
         gold.begin(), gold.end(), gold.begin(), [](float n) -> float { return expf(n); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(exp_dyn_test)
@@ -68,5 +68,5 @@ TEST_CASE(exp_dyn_test)
     std::vector<float> gold = input_data;
     std::transform(
         gold.begin(), gold.end(), gold.begin(), [](float n) -> float { return expf(n); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/fill.cpp

@@ -51,7 +51,7 @@ TEST_CASE(fill_static_int)
     std::vector<int64_t> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<int64_t> gold(48, 3);
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(fill_dyn_float)
@@ -75,7 +75,7 @@ TEST_CASE(fill_dyn_float)
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold(72, 7.36);
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(fill_var_default_value)
@@ -98,5 +98,5 @@ TEST_CASE(fill_var_default_value)
     std::vector<int64_t> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<int64_t> gold(48, 2);
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/floor.cpp

@@ -45,7 +45,7 @@ TEST_CASE(floor_test)
     std::vector<float> gold = data;
     std::transform(
         gold.begin(), gold.end(), gold.begin(), [](float n) -> float { return floor(n); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(floor_dyn_test)
@@ -68,5 +68,5 @@ TEST_CASE(floor_dyn_test)
     std::vector<float> gold = input_data;
     std::transform(
         gold.begin(), gold.end(), gold.begin(), [](float n) -> float { return floor(n); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/fmod.cpp

@@ -45,7 +45,7 @@ TEST_CASE(fmod_test)
     std::vector<float> results_vector(4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{-1, 0, -3};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(fmod_dyn_test)
@@ -73,7 +73,7 @@ TEST_CASE(fmod_dyn_test)
     std::vector<float> results_vector(4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{-1, 0, -3};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(fmod_float_test)
@@ -92,5 +92,5 @@ TEST_CASE(fmod_float_test)
     std::vector<float> results_vector(4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{-1.2f, 0.5f, -3.3f};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/gather.cpp

@@ -52,7 +52,7 @@ TEST_CASE(gather_non_std_test)
             0.5f, 1.5f, 2.5f, 6.5f, 7.5f, 8.5f, 0.5f, 1.5f, 2.5f, 6.5f, 7.5f, 8.5f};
         std::vector<float> res_data;
         result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-        EXPECT(migraphx::verify::verify_range(res_data, golden));
+        EXPECT(migraphx::verify::verify_rms_range(res_data, golden));
     }
 }
 
@@ -75,7 +75,7 @@ TEST_CASE(gather_test_1)
     std::vector<float> res_data(4 * 5);
     std::vector<float> golden = {0.5f, 1.5f, 2.5f, 6.5f, 7.5f, 8.5f};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(res_data, golden));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, golden));
 }
 
 TEST_CASE(gather_test_2)
@@ -97,7 +97,7 @@ TEST_CASE(gather_test_2)
     std::vector<float> res_data(4 * 5);
     std::vector<float> golden = {0.5f, 1.5f, 2.5f, 6.5f, 7.5f, 8.5f};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(res_data, golden));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, golden));
 }
 
 TEST_CASE(gather_test_3)
@@ -119,7 +119,7 @@ TEST_CASE(gather_test_3)
     std::vector<float> res_data(4 * 5);
     std::vector<float> golden = {0.5f, 2.5f, 3.5f, 5.5f, 6.5f, 8.5f};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(res_data, golden));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, golden));
 }
 
 TEST_CASE(gather_test_4)
@@ -141,7 +141,7 @@ TEST_CASE(gather_test_4)
     std::vector<float> res_data(4 * 5);
     std::vector<float> golden = {0.5f, 2.5f, 3.5f, 5.5f, 6.5f, 8.5f};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(res_data, golden));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, golden));
 }
 
 TEST_CASE(gather_test_5)
@@ -164,7 +164,7 @@ TEST_CASE(gather_test_5)
     std::vector<float> res_data{};
     std::vector<float> golden = {0.5f, 3.5f, 6.5f};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(res_data, golden));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, golden));
 }
 
 TEST_CASE(gather_test_6)
@@ -187,7 +187,7 @@ TEST_CASE(gather_test_6)
     std::vector<float> res_data{};
     std::vector<float> golden = {0.5f, 3.5f, 6.5f};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(res_data, golden));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, golden));
 }
 
 TEST_CASE(gather_test_7)
@@ -210,7 +210,7 @@ TEST_CASE(gather_test_7)
     std::vector<float> res_data{};
     std::vector<float> golden = {0.5f};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(res_data, golden));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, golden));
 }
 
 TEST_CASE(gather_dyn_test0)
@@ -243,7 +243,7 @@ TEST_CASE(gather_dyn_test0)
     std::vector<int> gold = {1, 2, 4, 5};
     std::vector<int> results_vector(2 * 1 * 2);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
     migraphx::shape sfinal{migraphx::shape::int32_type, {2, 1, 2}};
     EXPECT(result.get_shape() == sfinal);
 }
@@ -280,7 +280,7 @@ TEST_CASE(gather_dyn_test1)
     std::vector<int> results_vector(1 * 2 * 4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
     migraphx::shape sfinal{migraphx::shape::int32_type, {1, 2, 4}};
     EXPECT(result.get_shape() == sfinal);
 }

test/ref/gathernd.cpp

@@ -52,7 +52,7 @@ TEST_CASE(gathernd_test_1)
     std::vector<float> gold{0, 3};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_test_2)
@@ -77,7 +77,7 @@ TEST_CASE(gathernd_test_2)
     std::vector<float> gold{2, 3, 0, 1};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_test_3)
@@ -102,7 +102,7 @@ TEST_CASE(gathernd_test_3)
     std::vector<float> gold{3, 4, 5, 0, 1, 2, 0, 1, 2, 3, 4, 5};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_test_4)
@@ -128,7 +128,7 @@ TEST_CASE(gathernd_test_4)
     std::vector<float> gold{0, 1, 2, 3, 4, 5, 18, 19, 20, 21, 22, 23};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_test_5)
@@ -155,7 +155,7 @@ TEST_CASE(gathernd_test_5)
     std::vector<float> gold{0, 4, 8, 11, 13, 15};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_test_6)
@@ -215,7 +215,7 @@ TEST_CASE(gathernd_dynamic0)
     std::vector<float> gold{3, 4, 5, 0, 1, 2, 0, 1, 2, 3, 4, 5};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_dynamic1)
@@ -251,7 +251,7 @@ TEST_CASE(gathernd_dynamic1)
     std::vector<float> gold{3, 4, 5, 0, 1, 2, 0, 1, 2, 3, 4, 5};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_dynamic2)
@@ -287,7 +287,7 @@ TEST_CASE(gathernd_dynamic2)
     std::vector<float> gold{3, 4, 5, 0, 1, 2, 0, 1, 2, 3, 4, 5};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_dynamic3)
@@ -323,7 +323,7 @@ TEST_CASE(gathernd_dynamic3)
     std::vector<float> res_data{};
     std::vector<float> gold{1, 0, 3, 4};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_dynamic4)
@@ -358,7 +358,7 @@ TEST_CASE(gathernd_dynamic4)
     std::vector<float> res_data{};
     std::vector<float> gold{5};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_negative_index_test_1)
@@ -383,7 +383,7 @@ TEST_CASE(gathernd_negative_index_test_1)
     std::vector<float> gold{2, 3, 0, 1};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_negative_index_test_2)

test/ref/im2col.cpp

@@ -61,7 +61,7 @@ TEST_CASE(im2col_3x3_no_pad_identity_test)
     std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
     std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(im2col_3x3_no_pad_test)
@@ -98,7 +98,7 @@ TEST_CASE(im2col_3x3_no_pad_test)
     std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
     std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(im2col_3x3_stride_2_no_pad_test)
@@ -136,7 +136,7 @@ TEST_CASE(im2col_3x3_stride_2_no_pad_test)
     std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
     std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(im2col_3x3_with_channels_identity_test)
@@ -170,7 +170,7 @@ TEST_CASE(im2col_3x3_with_channels_identity_test)
     std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
     std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(im2col_3x3_with_padding_test)
@@ -207,5 +207,5 @@ TEST_CASE(im2col_3x3_with_padding_test)
     std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
     std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/isnan.cpp

@@ -46,7 +46,7 @@ TEST_CASE(isnan_test)
         std::vector<float> results_vector;
         result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
         std::vector<float> gold = {0, 0, 1, 1, 0, 0};
-        EXPECT(migraphx::verify::verify_range(results_vector, gold));
+        EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
     }
 
     // half test
@@ -65,7 +65,7 @@ TEST_CASE(isnan_test)
         std::vector<float> results_vector;
         result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
         std::vector<float> gold = {0, 0, 1, 1, 0, 0};
-        EXPECT(migraphx::verify::verify_range(results_vector, gold));
+        EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
     }
 }
 
@@ -87,5 +87,5 @@ TEST_CASE(isnan_dyn_test)
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0, 0, 1, 1, 0, 0};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/leaky_relu.cpp

@@ -42,5 +42,5 @@ TEST_CASE(leaky_relu_test)
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {-0.01f, 0.f, 1.f};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }