Pulling test/prims/test_utils.h out of raft namespace and into MLCommon

cpp/test/prims/add_sub_dev_scalar.cu

@@ -91,7 +91,7 @@ typedef DevScalarTest<float, int> DevScalarTestF_i32;
 TEST_P(DevScalarTestF_i32, Result)
 {
   ASSERT_TRUE(devArrMatch(
-    out_ref.data(), out.data(), params.len, raft::CompareApprox<float>(params.tolerance)));
+    out_ref.data(), out.data(), params.len, MLCommon::CompareApprox<float>(params.tolerance)));
 }
 INSTANTIATE_TEST_CASE_P(DevScalarTests, DevScalarTestF_i32, ::testing::ValuesIn(inputsf_i32));
 
@@ -101,7 +101,7 @@ typedef DevScalarTest<float, size_t> DevScalarTestF_i64;
 TEST_P(DevScalarTestF_i64, Result)
 {
   ASSERT_TRUE(devArrMatch(
-    out_ref.data(), out.data(), params.len, raft::CompareApprox<float>(params.tolerance)));
+    out_ref.data(), out.data(), params.len, MLCommon::CompareApprox<float>(params.tolerance)));
 }
 INSTANTIATE_TEST_CASE_P(DevScalarTests, DevScalarTestF_i64, ::testing::ValuesIn(inputsf_i64));
 
@@ -111,7 +111,7 @@ typedef DevScalarTest<double, int> DevScalarTestD_i32;
 TEST_P(DevScalarTestD_i32, Result)
 {
   ASSERT_TRUE(devArrMatch(
-    out_ref.data(), out.data(), params.len, raft::CompareApprox<double>(params.tolerance)));
+    out_ref.data(), out.data(), params.len, MLCommon::CompareApprox<double>(params.tolerance)));
 }
 INSTANTIATE_TEST_CASE_P(DevScalarTests, DevScalarTestD_i32, ::testing::ValuesIn(inputsd_i32));
 
@@ -121,7 +121,7 @@ typedef DevScalarTest<double, size_t> DevScalarTestD_i64;
 TEST_P(DevScalarTestD_i64, Result)
 {
   ASSERT_TRUE(devArrMatch(
-    out_ref.data(), out.data(), params.len, raft::CompareApprox<double>(params.tolerance)));
+    out_ref.data(), out.data(), params.len, MLCommon::CompareApprox<double>(params.tolerance)));
 }
 INSTANTIATE_TEST_CASE_P(DevScalarTests, DevScalarTestD_i64, ::testing::ValuesIn(inputsd_i64));
 

cpp/test/prims/batched/csr.cu

@@ -206,15 +206,15 @@ TEST_P(BatchedCSRTestD, Result)
   ASSERT_TRUE(devArrMatchHost(res_h.data(),
                               res_bM->raw_data(),
                               res_h.size(),
-                              raft::CompareApprox<double>(params.tolerance),
+                              MLCommon::CompareApprox<double>(params.tolerance),
                               stream));
 }
 TEST_P(BatchedCSRTestF, Result)
 {
   ASSERT_TRUE(devArrMatchHost(res_h.data(),
                               res_bM->raw_data(),
                               res_h.size(),
-                              raft::CompareApprox<float>(params.tolerance),
+                              MLCommon::CompareApprox<float>(params.tolerance),
                               stream));
 }
 

cpp/test/prims/batched/gemv.cu

@@ -120,8 +120,8 @@ typedef BatchGemvTest<float> BatchGemvTestF;
 TEST_P(BatchGemvTestF, Result)
 {
   int vecleny = params.batchSize * params.m;
-  ASSERT_TRUE(
-    devArrMatch(out_ref.data(), out.data(), vecleny, raft::CompareApprox<float>(params.tolerance)));
+  ASSERT_TRUE(devArrMatch(
+    out_ref.data(), out.data(), vecleny, MLCommon::CompareApprox<float>(params.tolerance)));
 }
 INSTANTIATE_TEST_CASE_P(BatchGemvTests, BatchGemvTestF, ::testing::ValuesIn(inputsf));
 
@@ -141,7 +141,7 @@ TEST_P(BatchGemvTestD, Result)
 {
   int vecleny = params.batchSize * params.m;
   ASSERT_TRUE(devArrMatch(
-    out_ref.data(), out.data(), vecleny, raft::CompareApprox<double>(params.tolerance)));
+    out_ref.data(), out.data(), vecleny, MLCommon::CompareApprox<double>(params.tolerance)));
 }
 INSTANTIATE_TEST_CASE_P(BatchGemvTests, BatchGemvTestD, ::testing::ValuesIn(inputsd));
 

cpp/test/prims/batched/make_symm.cu

@@ -102,7 +102,7 @@ TEST_P(BatchMakeSymmTestF, Result)
 {
   int len = params.batchSize * params.n * params.n;
   ASSERT_TRUE(
-    devArrMatch(out_ref.data(), out.data(), len, raft::CompareApprox<float>(params.tolerance)));
+    devArrMatch(out_ref.data(), out.data(), len, MLCommon::CompareApprox<float>(params.tolerance)));
 }
 INSTANTIATE_TEST_CASE_P(BatchMakeSymmTests, BatchMakeSymmTestF, ::testing::ValuesIn(inputsf));
 
@@ -115,8 +115,8 @@ const std::vector<BatchMakeSymmInputs<double>> inputsd = {
 TEST_P(BatchMakeSymmTestD, Result)
 {
   int len = params.batchSize * params.n * params.n;
-  ASSERT_TRUE(
-    devArrMatch(out_ref.data(), out.data(), len, raft::CompareApprox<double>(params.tolerance)));
+  ASSERT_TRUE(devArrMatch(
+    out_ref.data(), out.data(), len, MLCommon::CompareApprox<double>(params.tolerance)));
 }
 INSTANTIATE_TEST_CASE_P(BatchMakeSymmTests, BatchMakeSymmTestD, ::testing::ValuesIn(inputsd));
 

cpp/test/prims/batched/matrix.cu

@@ -22,11 +22,11 @@
 #include <raft/linalg/add.cuh>
 #include <raft/util/cudart_utils.hpp>
 
-#include <gtest/gtest.h>
-
 #include <algorithm>
 #include <cmath>
 #include <cstddef>
+#include <gtest/gtest.h>
+#include <raft/core/math.hpp>
 #include <random>
 #include <vector>
 
@@ -447,19 +447,19 @@ using BatchedMatrixTestD = MatrixTest<double>;
 using BatchedMatrixTestF = MatrixTest<float>;
 TEST_P(BatchedMatrixTestD, Result)
 {
-  ASSERT_TRUE(raft::devArrMatchHost(res_h.data(),
-                                    res_bM->raw_data(),
-                                    res_h.size(),
-                                    raft::CompareApprox<double>(params.tolerance),
-                                    stream));
+  ASSERT_TRUE(MLCommon::devArrMatchHost(res_h.data(),
+                                        res_bM->raw_data(),
+                                        res_h.size(),
+                                        MLCommon::CompareApprox<double>(params.tolerance),
+                                        stream));
 }
 TEST_P(BatchedMatrixTestF, Result)
 {
-  ASSERT_TRUE(raft::devArrMatchHost(res_h.data(),
-                                    res_bM->raw_data(),
-                                    res_h.size(),
-                                    raft::CompareApprox<float>(params.tolerance),
-                                    stream));
+  ASSERT_TRUE(MLCommon::devArrMatchHost(res_h.data(),
+                                        res_bM->raw_data(),
+                                        res_h.size(),
+                                        MLCommon::CompareApprox<float>(params.tolerance),
+                                        stream));
 }
 
 INSTANTIATE_TEST_CASE_P(BatchedMatrixTests, BatchedMatrixTestD, ::testing::ValuesIn(inputsd));

cpp/test/prims/decoupled_lookback.cu

@@ -92,7 +92,7 @@ template <typename T, typename L>
 const std::vector<DlbInputs> inputs = {{4}, {16}, {64}, {256}, {2048}};
 TEST_P(DlbTest, Result)
 {
-  ASSERT_TRUE(devArrMatchCustom(out.data(), params.len, raft::Compare<int>()));
+  ASSERT_TRUE(devArrMatchCustom(out.data(), params.len, MLCommon::Compare<int>()));
 }
 INSTANTIATE_TEST_CASE_P(DlbTests, DlbTest, ::testing::ValuesIn(inputs));
 

cpp/test/prims/device_utils.cu

@@ -117,7 +117,7 @@ const std::vector<BatchedBlockReduceInputs> inputs = {
 
 TEST_P(BBTest8, Result)
 {
-  ASSERT_TRUE(devArrMatch(refOut.data(), out.data(), 8, raft::Compare<int>()));
+  ASSERT_TRUE(devArrMatch(refOut.data(), out.data(), 8, MLCommon::Compare<int>()));
 }
 INSTANTIATE_TEST_CASE_P(BatchedBlockReduceTests, BBTest8, ::testing::ValuesIn(inputs));
 

cpp/test/prims/dist_adj.cu

@@ -147,7 +147,7 @@ TEST_P(DistanceAdjTestF, Result)
 {
   int m = params.isRowMajor ? params.m : params.n;
   int n = params.isRowMajor ? params.n : params.m;
-  ASSERT_TRUE(devArrMatch(dist_ref.data(), dist.data(), m, n, raft::Compare<bool>()));
+  ASSERT_TRUE(devArrMatch(dist_ref.data(), dist.data(), m, n, MLCommon::Compare<bool>()));
 }
 INSTANTIATE_TEST_CASE_P(DistanceAdjTests, DistanceAdjTestF, ::testing::ValuesIn(inputsf));
 
@@ -166,7 +166,7 @@ TEST_P(DistanceAdjTestD, Result)
 {
   int m = params.isRowMajor ? params.m : params.n;
   int n = params.isRowMajor ? params.n : params.m;
-  ASSERT_TRUE(devArrMatch(dist_ref.data(), dist.data(), m, n, raft::Compare<bool>()));
+  ASSERT_TRUE(devArrMatch(dist_ref.data(), dist.data(), m, n, MLCommon::Compare<bool>()));
 }
 INSTANTIATE_TEST_CASE_P(DistanceAdjTests, DistanceAdjTestD, ::testing::ValuesIn(inputsd));
 

cpp/test/prims/eltwise2d.cu

@@ -132,17 +132,19 @@ const std::vector<Eltwise2dInputs<double>> inputsd2 = {{0.00000001, 1024, 1024,
 typedef Eltwise2dTest<float> Eltwise2dTestF;
 TEST_P(Eltwise2dTestF, Result)
 {
-  ASSERT_TRUE(raft::devArrMatch(
-    out_ref.data(), out.data(), params.w * params.h, raft::CompareApprox<float>(params.tolerance)));
+  ASSERT_TRUE(MLCommon::devArrMatch(out_ref.data(),
+                                    out.data(),
+                                    params.w * params.h,
+                                    MLCommon::CompareApprox<float>(params.tolerance)));
 }
 
 typedef Eltwise2dTest<double> Eltwise2dTestD;
 TEST_P(Eltwise2dTestD, Result)
 {
-  ASSERT_TRUE(raft::devArrMatch(out_ref.data(),
-                                out.data(),
-                                params.w * params.h,
-                                raft::CompareApprox<double>(params.tolerance)));
+  ASSERT_TRUE(MLCommon::devArrMatch(out_ref.data(),
+                                    out.data(),
+                                    params.w * params.h,
+                                    MLCommon::CompareApprox<double>(params.tolerance)));
 }
 
 INSTANTIATE_TEST_CASE_P(Eltwise2dTests, Eltwise2dTestF, ::testing::ValuesIn(inputsf2));

cpp/test/prims/fast_int_div.cu

@@ -92,7 +92,7 @@ TEST(FastIntDiv, GpuTest)
     fastIntDivTestKernel<<<nblks, TPB, 0, 0>>>(
       computed.data(), correct.data(), in.data(), fid, divisor, len);
     RAFT_CUDA_TRY(cudaStreamSynchronize(0));
-    ASSERT_TRUE(devArrMatch(correct.data(), computed.data(), len * 2, raft::Compare<int>()))
+    ASSERT_TRUE(devArrMatch(correct.data(), computed.data(), len * 2, MLCommon::Compare<int>()))
       << " divisor=" << divisor;
   }
 }

cpp/test/prims/fillna.cu

@@ -135,7 +135,7 @@ class FillnaTest : public ::testing::TestWithParam<FillnaInputs<T>> {
     match = devArrMatchHost(h_y.data(),
                             y.data(),
                             params.n_obs * params.batch_size,
-                            raft::CompareApprox<T>(params.tolerance),
+                            MLCommon::CompareApprox<T>(params.tolerance),
                             handle.get_stream());
   }
 

cpp/test/prims/grid_sync.cu

@@ -123,9 +123,9 @@ TEST_P(GridSyncTest, Result)
                                          : params.gridDim.x * params.gridDim.y * params.gridDim.z;
   int nthreads = params.blockDim.x * params.blockDim.y * params.blockDim.z;
   int expected = (nblks * nthreads) + 1;
-  ASSERT_TRUE(raft::devArrMatch(expected, out.data(), len, raft::Compare<int>()));
+  ASSERT_TRUE(MLCommon::devArrMatch(expected, out.data(), len, MLCommon::Compare<int>()));
   if (params.checkWorkspaceReuse) {
-    ASSERT_TRUE(raft::devArrMatch(expected, out1.data(), len, raft::Compare<int>()));
+    ASSERT_TRUE(MLCommon::devArrMatch(expected, out1.data(), len, MLCommon::Compare<int>()));
   }
 }
 INSTANTIATE_TEST_CASE_P(GridSyncTests, GridSyncTest, ::testing::ValuesIn(inputs));

cpp/test/prims/hinge.cu

@@ -232,77 +232,77 @@ const std::vector<HingeLossInputs<double>> inputsd = {{0.01, 3, 2, 6}};
 typedef HingeLossTest<float> HingeLossTestF;
 TEST_P(HingeLossTestF, Result)
 {
-  ASSERT_TRUE(
-    raft::devArrMatch(out_ref.data(), out.data(), 1, raft::CompareApprox<float>(params.tolerance)));
-
-  ASSERT_TRUE(raft::devArrMatch(
-    out_lasso_ref.data(), out_lasso.data(), 1, raft::CompareApprox<float>(params.tolerance)));
-
-  ASSERT_TRUE(raft::devArrMatch(
-    out_ridge_ref.data(), out_ridge.data(), 1, raft::CompareApprox<float>(params.tolerance)));
-
-  ASSERT_TRUE(raft::devArrMatch(out_elasticnet_ref.data(),
-                                out_elasticnet.data(),
-                                1,
-                                raft::CompareApprox<float>(params.tolerance)));
-
-  ASSERT_TRUE(raft::devArrMatch(out_grad_ref.data(),
-                                out_grad.data(),
-                                params.n_cols,
-                                raft::CompareApprox<float>(params.tolerance)));
-
-  ASSERT_TRUE(raft::devArrMatch(out_lasso_grad_ref.data(),
-                                out_lasso_grad.data(),
-                                params.n_cols,
-                                raft::CompareApprox<float>(params.tolerance)));
-
-  ASSERT_TRUE(raft::devArrMatch(out_ridge_grad_ref.data(),
-                                out_ridge_grad.data(),
-                                params.n_cols,
-                                raft::CompareApprox<float>(params.tolerance)));
-
-  ASSERT_TRUE(raft::devArrMatch(out_elasticnet_grad_ref.data(),
-                                out_elasticnet_grad.data(),
-                                params.n_cols,
-                                raft::CompareApprox<float>(params.tolerance)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    out_ref.data(), out.data(), 1, MLCommon::CompareApprox<float>(params.tolerance)));
+
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    out_lasso_ref.data(), out_lasso.data(), 1, MLCommon::CompareApprox<float>(params.tolerance)));
+
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    out_ridge_ref.data(), out_ridge.data(), 1, MLCommon::CompareApprox<float>(params.tolerance)));
+
+  ASSERT_TRUE(MLCommon::devArrMatch(out_elasticnet_ref.data(),
+                                    out_elasticnet.data(),
+                                    1,
+                                    MLCommon::CompareApprox<float>(params.tolerance)));
+
+  ASSERT_TRUE(MLCommon::devArrMatch(out_grad_ref.data(),
+                                    out_grad.data(),
+                                    params.n_cols,
+                                    MLCommon::CompareApprox<float>(params.tolerance)));
+
+  ASSERT_TRUE(MLCommon::devArrMatch(out_lasso_grad_ref.data(),
+                                    out_lasso_grad.data(),
+                                    params.n_cols,
+                                    MLCommon::CompareApprox<float>(params.tolerance)));
+
+  ASSERT_TRUE(MLCommon::devArrMatch(out_ridge_grad_ref.data(),
+                                    out_ridge_grad.data(),
+                                    params.n_cols,
+                                    MLCommon::CompareApprox<float>(params.tolerance)));
+
+  ASSERT_TRUE(MLCommon::devArrMatch(out_elasticnet_grad_ref.data(),
+                                    out_elasticnet_grad.data(),
+                                    params.n_cols,
+                                    MLCommon::CompareApprox<float>(params.tolerance)));
 }
 
 typedef HingeLossTest<double> HingeLossTestD;
 TEST_P(HingeLossTestD, Result)
 {
-  ASSERT_TRUE(raft::devArrMatch(
-    out_ref.data(), out.data(), 1, raft::CompareApprox<double>(params.tolerance)));
-
-  ASSERT_TRUE(raft::devArrMatch(
-    out_lasso_ref.data(), out_lasso.data(), 1, raft::CompareApprox<double>(params.tolerance)));
-
-  ASSERT_TRUE(raft::devArrMatch(
-    out_ridge_ref.data(), out_ridge.data(), 1, raft::CompareApprox<double>(params.tolerance)));
-
-  ASSERT_TRUE(raft::devArrMatch(out_elasticnet_ref.data(),
-                                out_elasticnet.data(),
-                                1,
-                                raft::CompareApprox<double>(params.tolerance)));
-
-  ASSERT_TRUE(raft::devArrMatch(out_grad_ref.data(),
-                                out_grad.data(),
-                                params.n_cols,
-                                raft::CompareApprox<double>(params.tolerance)));
-
-  ASSERT_TRUE(raft::devArrMatch(out_lasso_grad_ref.data(),
-                                out_lasso_grad.data(),
-                                params.n_cols,
-                                raft::CompareApprox<double>(params.tolerance)));
-
-  ASSERT_TRUE(raft::devArrMatch(out_ridge_grad_ref.data(),
-                                out_ridge_grad.data(),
-                                params.n_cols,
-                                raft::CompareApprox<double>(params.tolerance)));
-
-  ASSERT_TRUE(raft::devArrMatch(out_elasticnet_grad_ref.data(),
-                                out_elasticnet_grad.data(),
-                                params.n_cols,
-                                raft::CompareApprox<double>(params.tolerance)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    out_ref.data(), out.data(), 1, MLCommon::CompareApprox<double>(params.tolerance)));
+
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    out_lasso_ref.data(), out_lasso.data(), 1, MLCommon::CompareApprox<double>(params.tolerance)));
+
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    out_ridge_ref.data(), out_ridge.data(), 1, MLCommon::CompareApprox<double>(params.tolerance)));
+
+  ASSERT_TRUE(MLCommon::devArrMatch(out_elasticnet_ref.data(),
+                                    out_elasticnet.data(),
+                                    1,
+                                    MLCommon::CompareApprox<double>(params.tolerance)));
+
+  ASSERT_TRUE(MLCommon::devArrMatch(out_grad_ref.data(),
+                                    out_grad.data(),
+                                    params.n_cols,
+                                    MLCommon::CompareApprox<double>(params.tolerance)));
+
+  ASSERT_TRUE(MLCommon::devArrMatch(out_lasso_grad_ref.data(),
+                                    out_lasso_grad.data(),
+                                    params.n_cols,
+                                    MLCommon::CompareApprox<double>(params.tolerance)));
+
+  ASSERT_TRUE(MLCommon::devArrMatch(out_ridge_grad_ref.data(),
+                                    out_ridge_grad.data(),
+                                    params.n_cols,
+                                    MLCommon::CompareApprox<double>(params.tolerance)));
+
+  ASSERT_TRUE(MLCommon::devArrMatch(out_elasticnet_grad_ref.data(),
+                                    out_elasticnet_grad.data(),
+                                    params.n_cols,
+                                    MLCommon::CompareApprox<double>(params.tolerance)));
 }
 
 INSTANTIATE_TEST_CASE_P(HingeLossTests, HingeLossTestF, ::testing::ValuesIn(inputsf));