diff --git a/cpp/test/prims/add_sub_dev_scalar.cu b/cpp/test/prims/add_sub_dev_scalar.cu
index 910ea583c8..115c4e29bd 100644
--- a/cpp/test/prims/add_sub_dev_scalar.cu
+++ b/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));
 
diff --git a/cpp/test/prims/batched/csr.cu b/cpp/test/prims/batched/csr.cu
index 57da86a7fa..9ad7825d49 100644
--- a/cpp/test/prims/batched/csr.cu
+++ b/cpp/test/prims/batched/csr.cu
@@ -206,7 +206,7 @@ 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)
@@ -214,7 +214,7 @@ 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));
 }
 
diff --git a/cpp/test/prims/batched/gemv.cu b/cpp/test/prims/batched/gemv.cu
index d96b480adb..78fd3b8e3b 100644
--- a/cpp/test/prims/batched/gemv.cu
+++ b/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));
 
diff --git a/cpp/test/prims/batched/make_symm.cu b/cpp/test/prims/batched/make_symm.cu
index bee15b6477..43206593ff 100644
--- a/cpp/test/prims/batched/make_symm.cu
+++ b/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));
 
diff --git a/cpp/test/prims/batched/matrix.cu b/cpp/test/prims/batched/matrix.cu
index 47fb072dbc..250efe5157 100644
--- a/cpp/test/prims/batched/matrix.cu
+++ b/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));
diff --git a/cpp/test/prims/decoupled_lookback.cu b/cpp/test/prims/decoupled_lookback.cu
index 7a7911ffc4..79b3482394 100644
--- a/cpp/test/prims/decoupled_lookback.cu
+++ b/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));
 
diff --git a/cpp/test/prims/device_utils.cu b/cpp/test/prims/device_utils.cu
index 25369171a4..181cdfcb60 100644
--- a/cpp/test/prims/device_utils.cu
+++ b/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));
 
diff --git a/cpp/test/prims/dist_adj.cu b/cpp/test/prims/dist_adj.cu
index db719cdf4b..8cc79a4363 100644
--- a/cpp/test/prims/dist_adj.cu
+++ b/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));
 
diff --git a/cpp/test/prims/eltwise2d.cu b/cpp/test/prims/eltwise2d.cu
index c7ff972f1d..418df99faa 100644
--- a/cpp/test/prims/eltwise2d.cu
+++ b/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));
diff --git a/cpp/test/prims/fast_int_div.cu b/cpp/test/prims/fast_int_div.cu
index f4e742018a..607e632a6d 100644
--- a/cpp/test/prims/fast_int_div.cu
+++ b/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;
   }
 }
diff --git a/cpp/test/prims/fillna.cu b/cpp/test/prims/fillna.cu
index ed791c8650..2745eb63c7 100644
--- a/cpp/test/prims/fillna.cu
+++ b/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());
   }
 
diff --git a/cpp/test/prims/grid_sync.cu b/cpp/test/prims/grid_sync.cu
index c7f6fdb9da..8515c0301a 100644
--- a/cpp/test/prims/grid_sync.cu
+++ b/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));
diff --git a/cpp/test/prims/hinge.cu b/cpp/test/prims/hinge.cu
index b42324db69..a0d003b87e 100644
--- a/cpp/test/prims/hinge.cu
+++ b/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));
diff --git a/cpp/test/prims/jones_transform.cu b/cpp/test/prims/jones_transform.cu
index 7a992fd32f..2ae8b57f58 100644
--- a/cpp/test/prims/jones_transform.cu
+++ b/cpp/test/prims/jones_transform.cu
@@ -242,28 +242,28 @@ const std::vector<JonesTransParam> inputs = {{500, 4, 0.001},
 typedef JonesTransTest<double> JonesTransTestClass;
 TEST_P(JonesTransTestClass, Result)
 {
-  ASSERT_TRUE(raft::devArrMatch(d_golden_ar_trans.data(),
-                                d_computed_ar_trans.data(),
-                                nElements,
-                                raft::CompareApprox<double>(params.tolerance)));
-  ASSERT_TRUE(raft::devArrMatch(d_golden_ma_trans.data(),
-                                d_computed_ma_trans.data(),
-                                nElements,
-                                raft::CompareApprox<double>(params.tolerance)));
+  ASSERT_TRUE(MLCommon::devArrMatch(d_golden_ar_trans.data(),
+                                    d_computed_ar_trans.data(),
+                                    nElements,
+                                    MLCommon::CompareApprox<double>(params.tolerance)));
+  ASSERT_TRUE(MLCommon::devArrMatch(d_golden_ma_trans.data(),
+                                    d_computed_ma_trans.data(),
+                                    nElements,
+                                    MLCommon::CompareApprox<double>(params.tolerance)));
   /*
   Test verifying the inversion property:
   initially generated random coefficients -> ar_param_transform() / ma_param_transform() ->
   transformed coefficients -> ar_param_inverse_transform()/ma_param_inverse_transform() ->
   initially generated random coefficients
   */
-  ASSERT_TRUE(raft::devArrMatch(d_computed_ma_invtrans.data(),
-                                d_params.data(),
-                                nElements,
-                                raft::CompareApprox<double>(params.tolerance)));
-  ASSERT_TRUE(raft::devArrMatch(d_computed_ar_invtrans.data(),
-                                d_params.data(),
-                                nElements,
-                                raft::CompareApprox<double>(params.tolerance)));
+  ASSERT_TRUE(MLCommon::devArrMatch(d_computed_ma_invtrans.data(),
+                                    d_params.data(),
+                                    nElements,
+                                    MLCommon::CompareApprox<double>(params.tolerance)));
+  ASSERT_TRUE(MLCommon::devArrMatch(d_computed_ar_invtrans.data(),
+                                    d_params.data(),
+                                    nElements,
+                                    MLCommon::CompareApprox<double>(params.tolerance)));
 }
 INSTANTIATE_TEST_CASE_P(JonesTrans, JonesTransTestClass, ::testing::ValuesIn(inputs));
 
diff --git a/cpp/test/prims/knn_classify.cu b/cpp/test/prims/knn_classify.cu
index 21b250f207..69e1983cbb 100644
--- a/cpp/test/prims/knn_classify.cu
+++ b/cpp/test/prims/knn_classify.cu
@@ -124,7 +124,7 @@ typedef KNNClassifyTest KNNClassifyTestF;
 TEST_P(KNNClassifyTestF, Fit)
 {
   ASSERT_TRUE(
-    devArrMatch(train_labels.data(), pred_labels.data(), params.rows, raft::Compare<int>()));
+    devArrMatch(train_labels.data(), pred_labels.data(), params.rows, MLCommon::Compare<int>()));
 }
 
 const std::vector<KNNClassifyInputs> inputsf = {{100, 10, 2, 0.01f, 2},
diff --git a/cpp/test/prims/knn_regression.cu b/cpp/test/prims/knn_regression.cu
index e276e31839..1373a91578 100644
--- a/cpp/test/prims/knn_regression.cu
+++ b/cpp/test/prims/knn_regression.cu
@@ -146,7 +146,7 @@ typedef KNNRegressionTest KNNRegressionTestF;
 TEST_P(KNNRegressionTestF, Fit)
 {
   ASSERT_TRUE(devArrMatch(
-    train_labels.data(), pred_labels.data(), params.rows, raft::CompareApprox<float>(0.3)));
+    train_labels.data(), pred_labels.data(), params.rows, MLCommon::CompareApprox<float>(0.3)));
 }
 
 const std::vector<KNNRegressionInputs> inputsf = {{100, 10, 2, 0.01f, 2},
diff --git a/cpp/test/prims/linalg_block.cu b/cpp/test/prims/linalg_block.cu
index 8b772a8696..3be940bfec 100644
--- a/cpp/test/prims/linalg_block.cu
+++ b/cpp/test/prims/linalg_block.cu
@@ -139,7 +139,7 @@ class BlockGemmTest : public ::testing::TestWithParam<BlockGemmInputs<T>> {
     match = devArrMatchHost(h_c_ref.data(),
                             c.data(),
                             params.m * params.n * params.batch_size,
-                            raft::CompareApprox<T>(params.eps),
+                            MLCommon::CompareApprox<T>(params.eps),
                             handle.get_stream());
   }
 
@@ -351,7 +351,7 @@ class BlockGemvTest : public ::testing::TestWithParam<BlockGemvInputs<T>> {
     match = devArrMatchHost(h_y_ref.data(),
                             y.data(),
                             params.m * params.batch_size,
-                            raft::CompareApprox<T>(params.eps),
+                            MLCommon::CompareApprox<T>(params.eps),
                             handle.get_stream());
   }
 
@@ -483,7 +483,7 @@ class BlockDotTest : public ::testing::TestWithParam<BlockDotInputs<T>> {
     match = devArrMatchHost(h_dot_ref.data(),
                             dot_dev.data(),
                             params.batch_size,
-                            raft::CompareApprox<T>(params.eps),
+                            MLCommon::CompareApprox<T>(params.eps),
                             handle.get_stream());
   }
 
@@ -617,7 +617,7 @@ class BlockXaxtTest : public ::testing::TestWithParam<BlockXaxtInputs<T>> {
     match = devArrMatchHost(h_res_ref.data(),
                             res_dev.data(),
                             params.batch_size,
-                            raft::CompareApprox<T>(params.eps),
+                            MLCommon::CompareApprox<T>(params.eps),
                             handle.get_stream());
   }
 
@@ -719,7 +719,7 @@ class BlockAxTest : public ::testing::TestWithParam<BlockAxInputs<T>> {
     match = devArrMatchHost(h_y_ref.data(),
                             y.data(),
                             params.n * params.batch_size,
-                            raft::CompareApprox<T>(params.eps),
+                            MLCommon::CompareApprox<T>(params.eps),
                             handle.get_stream());
   }
 
@@ -823,7 +823,7 @@ class BlockCovStabilityTest : public ::testing::TestWithParam<BlockCovStabilityI
     match = devArrMatchHost(h_out.data(),
                             d_out.data(),
                             params.n * params.n * params.batch_size,
-                            raft::CompareApprox<T>(params.eps),
+                            MLCommon::CompareApprox<T>(params.eps),
                             handle.get_stream());
   }
 
diff --git a/cpp/test/prims/linearReg.cu b/cpp/test/prims/linearReg.cu
index 11ece59551..c524d17691 100644
--- a/cpp/test/prims/linearReg.cu
+++ b/cpp/test/prims/linearReg.cu
@@ -232,76 +232,76 @@ typedef LinRegLossTest<float> LinRegLossTestF;
 TEST_P(LinRegLossTestF, Result)
 {
   ASSERT_TRUE(
-    devArrMatch(out_ref.data(), out.data(), 1, raft::CompareApprox<float>(params.tolerance)));
+    devArrMatch(out_ref.data(), out.data(), 1, MLCommon::CompareApprox<float>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(
-    out_lasso_ref.data(), out_lasso.data(), 1, raft::CompareApprox<float>(params.tolerance)));
+    out_lasso_ref.data(), out_lasso.data(), 1, MLCommon::CompareApprox<float>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(
-    out_ridge_ref.data(), out_ridge.data(), 1, raft::CompareApprox<float>(params.tolerance)));
+    out_ridge_ref.data(), out_ridge.data(), 1, MLCommon::CompareApprox<float>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(out_elasticnet_ref.data(),
                           out_elasticnet.data(),
                           1,
-                          raft::CompareApprox<float>(params.tolerance)));
+                          MLCommon::CompareApprox<float>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(out_grad_ref.data(),
                           out_grad.data(),
                           params.n_cols,
-                          raft::CompareApprox<float>(params.tolerance)));
+                          MLCommon::CompareApprox<float>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(out_lasso_grad_ref.data(),
                           out_lasso_grad.data(),
                           params.n_cols,
-                          raft::CompareApprox<float>(params.tolerance)));
+                          MLCommon::CompareApprox<float>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(out_ridge_grad_ref.data(),
                           out_ridge_grad.data(),
                           params.n_cols,
-                          raft::CompareApprox<float>(params.tolerance)));
+                          MLCommon::CompareApprox<float>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(out_elasticnet_grad_ref.data(),
                           out_elasticnet_grad.data(),
                           params.n_cols,
-                          raft::CompareApprox<float>(params.tolerance)));
+                          MLCommon::CompareApprox<float>(params.tolerance)));
 }
 
 typedef LinRegLossTest<double> LinRegLossTestD;
 TEST_P(LinRegLossTestD, Result)
 {
   ASSERT_TRUE(
-    devArrMatch(out_ref.data(), out.data(), 1, raft::CompareApprox<double>(params.tolerance)));
+    devArrMatch(out_ref.data(), out.data(), 1, MLCommon::CompareApprox<double>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(
-    out_lasso_ref.data(), out_lasso.data(), 1, raft::CompareApprox<double>(params.tolerance)));
+    out_lasso_ref.data(), out_lasso.data(), 1, MLCommon::CompareApprox<double>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(
-    out_ridge_ref.data(), out_ridge.data(), 1, raft::CompareApprox<double>(params.tolerance)));
+    out_ridge_ref.data(), out_ridge.data(), 1, MLCommon::CompareApprox<double>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(out_elasticnet_ref.data(),
                           out_elasticnet.data(),
                           1,
-                          raft::CompareApprox<double>(params.tolerance)));
+                          MLCommon::CompareApprox<double>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(out_grad_ref.data(),
                           out_grad.data(),
                           params.n_cols,
-                          raft::CompareApprox<double>(params.tolerance)));
+                          MLCommon::CompareApprox<double>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(out_lasso_grad_ref.data(),
                           out_lasso_grad.data(),
                           params.n_cols,
-                          raft::CompareApprox<double>(params.tolerance)));
+                          MLCommon::CompareApprox<double>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(out_ridge_grad_ref.data(),
                           out_ridge_grad.data(),
                           params.n_cols,
-                          raft::CompareApprox<double>(params.tolerance)));
+                          MLCommon::CompareApprox<double>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(out_elasticnet_grad_ref.data(),
                           out_elasticnet_grad.data(),
                           params.n_cols,
-                          raft::CompareApprox<double>(params.tolerance)));
+                          MLCommon::CompareApprox<double>(params.tolerance)));
 }
 
 INSTANTIATE_TEST_CASE_P(LinRegLossTests, LinRegLossTestF, ::testing::ValuesIn(inputsf));
diff --git a/cpp/test/prims/log.cu b/cpp/test/prims/log.cu
index 3ef4f23007..140904a475 100644
--- a/cpp/test/prims/log.cu
+++ b/cpp/test/prims/log.cu
@@ -74,8 +74,10 @@ const std::vector<LogInputs<double>> inputsd2 = {{0.001, 4}};
 typedef LogTest<float> LogTestValF;
 TEST_P(LogTestValF, Result)
 {
-  ASSERT_TRUE(devArrMatch(
-    result_ref.data(), result.data(), params.len, raft::CompareApproxAbs<float>(params.tolerance)));
+  ASSERT_TRUE(devArrMatch(result_ref.data(),
+                          result.data(),
+                          params.len,
+                          MLCommon::CompareApproxAbs<float>(params.tolerance)));
 }
 
 typedef LogTest<double> LogTestValD;
@@ -84,7 +86,7 @@ TEST_P(LogTestValD, Result)
   ASSERT_TRUE(devArrMatch(result_ref.data(),
                           result.data(),
                           params.len,
-                          raft::CompareApproxAbs<double>(params.tolerance)));
+                          MLCommon::CompareApproxAbs<double>(params.tolerance)));
 }
 
 INSTANTIATE_TEST_CASE_P(LogTests, LogTestValF, ::testing::ValuesIn(inputsf2));
diff --git a/cpp/test/prims/logisticReg.cu b/cpp/test/prims/logisticReg.cu
index b1dcd2dd8b..ad607f6e2c 100644
--- a/cpp/test/prims/logisticReg.cu
+++ b/cpp/test/prims/logisticReg.cu
@@ -231,77 +231,77 @@ const std::vector<LogRegLossInputs<double>> inputsd = {{0.01, 3, 2, 6}};
 typedef LogRegLossTest<float> LogRegLossTestF;
 TEST_P(LogRegLossTestF, 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 LogRegLossTest<double> LogRegLossTestD;
 TEST_P(LogRegLossTestD, 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(LogRegLossTests, LogRegLossTestF, ::testing::ValuesIn(inputsf));
diff --git a/cpp/test/prims/penalty.cu b/cpp/test/prims/penalty.cu
index e3ead6b02e..0318e77421 100644
--- a/cpp/test/prims/penalty.cu
+++ b/cpp/test/prims/penalty.cu
@@ -107,60 +107,60 @@ typedef PenaltyTest<float> PenaltyTestF;
 TEST_P(PenaltyTestF, Result)
 {
   ASSERT_TRUE(devArrMatch(
-    out_lasso_ref.data(), out_lasso.data(), 1, raft::CompareApprox<float>(params.tolerance)));
+    out_lasso_ref.data(), out_lasso.data(), 1, MLCommon::CompareApprox<float>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(out_lasso_grad_ref.data(),
                           out_lasso_grad.data(),
                           params.len,
-                          raft::CompareApprox<float>(params.tolerance)));
+                          MLCommon::CompareApprox<float>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(
-    out_ridge_ref.data(), out_ridge.data(), 1, raft::CompareApprox<float>(params.tolerance)));
+    out_ridge_ref.data(), out_ridge.data(), 1, MLCommon::CompareApprox<float>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(out_ridge_grad_ref.data(),
                           out_ridge_grad.data(),
                           params.len,
-                          raft::CompareApprox<float>(params.tolerance)));
+                          MLCommon::CompareApprox<float>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(out_elasticnet_ref.data(),
                           out_elasticnet.data(),
                           1,
-                          raft::CompareApprox<float>(params.tolerance)));
+                          MLCommon::CompareApprox<float>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(out_elasticnet_grad_ref.data(),
                           out_elasticnet_grad.data(),
                           params.len,
-                          raft::CompareApprox<float>(params.tolerance)));
+                          MLCommon::CompareApprox<float>(params.tolerance)));
 }
 
 typedef PenaltyTest<double> PenaltyTestD;
 TEST_P(PenaltyTestD, Result)
 {
   ASSERT_TRUE(devArrMatch(
-    out_lasso_ref.data(), out_lasso.data(), 1, raft::CompareApprox<double>(params.tolerance)));
+    out_lasso_ref.data(), out_lasso.data(), 1, MLCommon::CompareApprox<double>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(out_lasso_grad_ref.data(),
                           out_lasso_grad.data(),
                           params.len,
-                          raft::CompareApprox<double>(params.tolerance)));
+                          MLCommon::CompareApprox<double>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(
-    out_ridge_ref.data(), out_ridge.data(), 1, raft::CompareApprox<double>(params.tolerance)));
+    out_ridge_ref.data(), out_ridge.data(), 1, MLCommon::CompareApprox<double>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(out_ridge_grad_ref.data(),
                           out_ridge_grad.data(),
                           params.len,
-                          raft::CompareApprox<double>(params.tolerance)));
+                          MLCommon::CompareApprox<double>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(out_elasticnet_ref.data(),
                           out_elasticnet.data(),
                           1,
-                          raft::CompareApprox<double>(params.tolerance)));
+                          MLCommon::CompareApprox<double>(params.tolerance)));
 
   ASSERT_TRUE(devArrMatch(out_elasticnet_grad_ref.data(),
                           out_elasticnet_grad.data(),
                           params.len,
-                          raft::CompareApprox<double>(params.tolerance)));
+                          MLCommon::CompareApprox<double>(params.tolerance)));
 }
 
 INSTANTIATE_TEST_CASE_P(PenaltyTests, PenaltyTestF, ::testing::ValuesIn(inputsf));
diff --git a/cpp/test/prims/reverse.cu b/cpp/test/prims/reverse.cu
index 2ac90ffeae..596b86e238 100644
--- a/cpp/test/prims/reverse.cu
+++ b/cpp/test/prims/reverse.cu
@@ -84,7 +84,7 @@ TEST_P(ReverseTestF, Result)
                           out.data(),
                           params.nrows,
                           params.ncols,
-                          raft::CompareApprox<float>(params.tolerance)));
+                          MLCommon::CompareApprox<float>(params.tolerance)));
 }
 INSTANTIATE_TEST_CASE_P(ReverseTests, ReverseTestF, ::testing::ValuesIn(inputsf));
 
@@ -104,7 +104,7 @@ TEST_P(ReverseTestD, Result)
                           out.data(),
                           params.nrows,
                           params.ncols,
-                          raft::CompareApprox<double>(params.tolerance)));
+                          MLCommon::CompareApprox<double>(params.tolerance)));
 }
 INSTANTIATE_TEST_CASE_P(ReverseTests, ReverseTestD, ::testing::ValuesIn(inputsd));
 
diff --git a/cpp/test/prims/sigmoid.cu b/cpp/test/prims/sigmoid.cu
index 7b10a31bce..bc8126779d 100644
--- a/cpp/test/prims/sigmoid.cu
+++ b/cpp/test/prims/sigmoid.cu
@@ -74,17 +74,19 @@ const std::vector<SigmoidInputs<double>> inputsd2 = {{0.001, 4}};
 typedef SigmoidTest<float> SigmoidTestValF;
 TEST_P(SigmoidTestValF, Result)
 {
-  ASSERT_TRUE(raft::devArrMatch(
-    result_ref.data(), result.data(), params.len, raft::CompareApproxAbs<float>(params.tolerance)));
+  ASSERT_TRUE(MLCommon::devArrMatch(result_ref.data(),
+                                    result.data(),
+                                    params.len,
+                                    MLCommon::CompareApproxAbs<float>(params.tolerance)));
 }
 
 typedef SigmoidTest<double> SigmoidTestValD;
 TEST_P(SigmoidTestValD, Result)
 {
-  ASSERT_TRUE(raft::devArrMatch(result_ref.data(),
-                                result.data(),
-                                params.len,
-                                raft::CompareApproxAbs<double>(params.tolerance)));
+  ASSERT_TRUE(MLCommon::devArrMatch(result_ref.data(),
+                                    result.data(),
+                                    params.len,
+                                    MLCommon::CompareApproxAbs<double>(params.tolerance)));
 }
 
 INSTANTIATE_TEST_CASE_P(SigmoidTests, SigmoidTestValF, ::testing::ValuesIn(inputsf2));
diff --git a/cpp/test/prims/test_utils.h b/cpp/test/prims/test_utils.h
index a0fa3a5fc3..1e7e00b246 100644
--- a/cpp/test/prims/test_utils.h
+++ b/cpp/test/prims/test_utils.h
@@ -22,7 +22,7 @@
 #include <raft/core/interruptible.hpp>
 #include <raft/cuda_utils.cuh>
 
-namespace raft {
+namespace MLCommon {
 
 template <typename T>
 struct Compare {
@@ -254,4 +254,4 @@ testing::AssertionResult match(const T expected, T actual, L eq_compare)
     ms /= args.runs;                                       \
   } while (0)
 
-};  // end namespace raft
+};  // namespace MLCommon
diff --git a/cpp/test/sg/cd_test.cu b/cpp/test/sg/cd_test.cu
index 3bf61fede1..e775b82032 100644
--- a/cpp/test/sg/cd_test.cu
+++ b/cpp/test/sg/cd_test.cu
@@ -240,14 +240,14 @@ const std::vector<CdInputs<double>> inputsd2 = {{0.01, 4, 2}};
 typedef CdTest<float> CdTestF;
 TEST_P(CdTestF, Fit)
 {
-  ASSERT_TRUE(raft::devArrMatch(
-    coef_ref.data(), coef.data(), params.n_col, raft::CompareApproxAbs<float>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef_ref.data(), coef.data(), params.n_col, MLCommon::CompareApproxAbs<float>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef2_ref.data(), coef2.data(), params.n_col, raft::CompareApproxAbs<float>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef2_ref.data(), coef2.data(), params.n_col, MLCommon::CompareApproxAbs<float>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef3_ref.data(), coef3.data(), params.n_col, raft::CompareApproxAbs<float>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef3_ref.data(), coef3.data(), params.n_col, MLCommon::CompareApproxAbs<float>(params.tol)));
 
   rmm::device_uvector<float> means_1(params.n_col, stream);
   rmm::device_uvector<float> means_2(params.n_col, stream);
@@ -260,29 +260,29 @@ TEST_P(CdTestF, Fit)
   raft::stats::meanvar(
     means_2.data(), vars_2.data(), data.data(), params.n_col, params.n_row, false, false, stream);
 
-  ASSERT_TRUE(raft::devArrMatch(
-    means_1.data(), means_2.data(), params.n_col, raft::CompareApprox<float>(0.0001)));
-  ASSERT_TRUE(raft::devArrMatch(
-    vars_1.data(), vars_2.data(), params.n_col, raft::CompareApprox<float>(0.0001)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    means_1.data(), means_2.data(), params.n_col, MLCommon::CompareApprox<float>(0.0001)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    vars_1.data(), vars_2.data(), params.n_col, MLCommon::CompareApprox<float>(0.0001)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef4_ref.data(), coef4.data(), params.n_col, raft::CompareApproxAbs<float>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef4_ref.data(), coef4.data(), params.n_col, MLCommon::CompareApproxAbs<float>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef5_ref.data(), coef5.data(), params.n_col, raft::CompareApproxAbs<float>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef5_ref.data(), coef5.data(), params.n_col, MLCommon::CompareApproxAbs<float>(params.tol)));
 }
 
 typedef CdTest<double> CdTestD;
 TEST_P(CdTestD, Fit)
 {
-  ASSERT_TRUE(raft::devArrMatch(
-    coef_ref.data(), coef.data(), params.n_col, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef_ref.data(), coef.data(), params.n_col, MLCommon::CompareApproxAbs<double>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef2_ref.data(), coef2.data(), params.n_col, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef2_ref.data(), coef2.data(), params.n_col, MLCommon::CompareApproxAbs<double>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef3_ref.data(), coef3.data(), params.n_col, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef3_ref.data(), coef3.data(), params.n_col, MLCommon::CompareApproxAbs<double>(params.tol)));
 
   rmm::device_uvector<double> means_1(params.n_col, stream);
   rmm::device_uvector<double> means_2(params.n_col, stream);
@@ -295,16 +295,16 @@ TEST_P(CdTestD, Fit)
   raft::stats::meanvar(
     means_2.data(), vars_2.data(), data.data(), params.n_col, params.n_row, false, false, stream);
 
-  ASSERT_TRUE(raft::devArrMatch(
-    means_1.data(), means_2.data(), params.n_col, raft::CompareApprox<double>(0.0001)));
-  ASSERT_TRUE(raft::devArrMatch(
-    vars_1.data(), vars_2.data(), params.n_col, raft::CompareApprox<double>(0.0001)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    means_1.data(), means_2.data(), params.n_col, MLCommon::CompareApprox<double>(0.0001)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    vars_1.data(), vars_2.data(), params.n_col, MLCommon::CompareApprox<double>(0.0001)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef4_ref.data(), coef4.data(), params.n_col, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef4_ref.data(), coef4.data(), params.n_col, MLCommon::CompareApproxAbs<double>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef5_ref.data(), coef5.data(), params.n_col, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef5_ref.data(), coef5.data(), params.n_col, MLCommon::CompareApproxAbs<double>(params.tol)));
 }
 
 INSTANTIATE_TEST_CASE_P(CdTests, CdTestF, ::testing::ValuesIn(inputsf2));
diff --git a/cpp/test/sg/dbscan_test.cu b/cpp/test/sg/dbscan_test.cu
index 221c06a0f7..f55f1e0e18 100644
--- a/cpp/test/sg/dbscan_test.cu
+++ b/cpp/test/sg/dbscan_test.cu
@@ -249,11 +249,11 @@ class Dbscan2DSimple : public ::testing::TestWithParam<DBScan2DArrayInputs<T>> {
       CUML_LOG_DEBUG("Score = %lf", score);
     }
 
-    EXPECT_TRUE(raft::devArrMatchHost(params.core_indices,
-                                      core_sample_indices_d.data(),
-                                      params.n_row,
-                                      raft::Compare<int>(),
-                                      stream));
+    EXPECT_TRUE(MLCommon::devArrMatchHost(params.core_indices,
+                                          core_sample_indices_d.data(),
+                                          params.n_row,
+                                          MLCommon::Compare<int>(),
+                                          stream));
   }
 
   void SetUp() override { basicTest(); }
diff --git a/cpp/test/sg/fil_test.cu b/cpp/test/sg/fil_test.cu
index 815af43932..63008cc627 100644
--- a/cpp/test/sg/fil_test.cu
+++ b/cpp/test/sg/fil_test.cu
@@ -587,21 +587,21 @@ class BaseFilTest : public testing::TestWithParam<FilTestParams> {
 
   void compare()
   {
-    ASSERT_TRUE(raft::devArrMatch(want_proba_d.data(),
-                                  proba_d.data(),
-                                  ps.num_proba_outputs(),
-                                  raft::CompareApprox<real_t>(ps.tolerance),
-                                  stream));
+    ASSERT_TRUE(MLCommon::devArrMatch(want_proba_d.data(),
+                                      proba_d.data(),
+                                      ps.num_proba_outputs(),
+                                      MLCommon::CompareApprox<real_t>(ps.tolerance),
+                                      stream));
     float tolerance = ps.leaf_algo == fil::leaf_algo_t::FLOAT_UNARY_BINARY
                         ? ps.tolerance
                         : std::numeric_limits<real_t>::epsilon();
     // in multi-class prediction, floats represent the most likely class
     // and would be generated by converting an int to float
-    ASSERT_TRUE(raft::devArrMatch(want_preds_d.data(),
-                                  preds_d.data(),
-                                  ps.num_rows,
-                                  raft::CompareApprox<real_t>(tolerance),
-                                  stream));
+    ASSERT_TRUE(MLCommon::devArrMatch(want_preds_d.data(),
+                                      preds_d.data(),
+                                      ps.num_rows,
+                                      MLCommon::CompareApprox<real_t>(tolerance),
+                                      stream));
   }
 
   fil::val_t<real_t> infer_one_tree(fil::dense_node<real_t>* root,
diff --git a/cpp/test/sg/genetic/evolution_test.cu b/cpp/test/sg/genetic/evolution_test.cu
index 6ce80d2402..410f84bde5 100644
--- a/cpp/test/sg/genetic/evolution_test.cu
+++ b/cpp/test/sg/genetic/evolution_test.cu
@@ -262,7 +262,7 @@ class GeneticEvolutionTest : public ::testing::Test {
 
 TEST_F(GeneticEvolutionTest, SymReg)
 {
-  raft::CompareApprox<float> compApprox(tolerance);
+  MLCommon::CompareApprox<float> compApprox(tolerance);
   program_t final_progs;
   final_progs = (program_t)rmm::mr::get_current_device_resource()->allocate(
     hyper_params.population_size * sizeof(program), stream);
diff --git a/cpp/test/sg/genetic/param_test.cu b/cpp/test/sg/genetic/param_test.cu
index 13a7a510cb..ab4d1849fa 100644
--- a/cpp/test/sg/genetic/param_test.cu
+++ b/cpp/test/sg/genetic/param_test.cu
@@ -59,7 +59,7 @@ TEST(Genetic, p_reproduce)
 {
   param p;
   auto ret = p.p_reproduce();
-  ASSERT_TRUE(raft::match(p.p_reproduce(), 0.07f, raft::CompareApprox<float>(0.0001f)));
+  ASSERT_TRUE(MLCommon::match(p.p_reproduce(), 0.07f, MLCommon::CompareApprox<float>(0.0001f)));
 }
 
 }  // namespace genetic
diff --git a/cpp/test/sg/genetic/program_test.cu b/cpp/test/sg/genetic/program_test.cu
index d07b629c51..d11a86f813 100644
--- a/cpp/test/sg/genetic/program_test.cu
+++ b/cpp/test/sg/genetic/program_test.cu
@@ -359,7 +359,7 @@ class GeneticProgramTest : public ::testing::Test {
 
 TEST_F(GeneticProgramTest, PearsonCoeff)
 {
-  raft::CompareApproxAbs<float> compApprox(tolerance);
+  MLCommon::CompareApproxAbs<float> compApprox(tolerance);
   float h_expected_score[2] = {0.09528403f, 0.08269963f};
   float h_score[2]          = {0.0f, 0.0f};
   rmm::device_uvector<float> d_score(2, stream);
@@ -407,7 +407,7 @@ TEST_F(GeneticProgramTest, PearsonCoeff)
 
 TEST_F(GeneticProgramTest, SpearmanCoeff)
 {
-  raft::CompareApproxAbs<float> compApprox(tolerance);
+  MLCommon::CompareApproxAbs<float> compApprox(tolerance);
   float h_score[2] = {0.0f, 0.0f};
   rmm::device_uvector<float> d_score(2, stream);
   hyper_params.metric = metric_t::spearman;
@@ -455,7 +455,7 @@ TEST_F(GeneticProgramTest, SpearmanCoeff)
 
 TEST_F(GeneticProgramTest, MeanSquareLoss)
 {
-  raft::CompareApprox<float> compApprox(tolerance);
+  MLCommon::CompareApprox<float> compApprox(tolerance);
   float h_score[2] = {0.0f, 0.0f};
   rmm::device_uvector<float> d_score(2, stream);
   hyper_params.metric = metric_t::mse;
@@ -502,7 +502,7 @@ TEST_F(GeneticProgramTest, MeanSquareLoss)
 
 TEST_F(GeneticProgramTest, MeanAbsoluteLoss)
 {
-  raft::CompareApprox<float> compApprox(tolerance);
+  MLCommon::CompareApprox<float> compApprox(tolerance);
   float h_score[2] = {0.0f, 0.0f};
   rmm::device_uvector<float> d_score(2, stream);
   hyper_params.metric = metric_t::mae;
@@ -551,7 +551,7 @@ TEST_F(GeneticProgramTest, MeanAbsoluteLoss)
 
 TEST_F(GeneticProgramTest, RMSLoss)
 {
-  raft::CompareApprox<float> compApprox(tolerance);
+  MLCommon::CompareApprox<float> compApprox(tolerance);
   float h_score[2] = {0.0f, 0.0f};
   rmm::device_uvector<float> d_score(2, stream);
   hyper_params.metric = metric_t::rmse;
@@ -600,7 +600,7 @@ TEST_F(GeneticProgramTest, RMSLoss)
 
 TEST_F(GeneticProgramTest, LogLoss)
 {
-  raft::CompareApprox<float> compApprox(tolerance);
+  MLCommon::CompareApprox<float> compApprox(tolerance);
   float h_score[2] = {0.0f, 0.0f};
   rmm::device_uvector<float> d_score(2, stream);
   hyper_params.metric = metric_t::logloss;
@@ -634,7 +634,7 @@ TEST_F(GeneticProgramTest, LogLoss)
 
 TEST_F(GeneticProgramTest, ProgramExecution)
 {
-  raft::CompareApprox<float> compApprox(tolerance);
+  MLCommon::CompareApprox<float> compApprox(tolerance);
 
   // Enable debug logging
   ML::Logger::get().setLevel(CUML_LEVEL_INFO);
@@ -666,7 +666,7 @@ TEST_F(GeneticProgramTest, ProgramExecution)
 
 TEST_F(GeneticProgramTest, ProgramFitnessScore)
 {
-  raft::CompareApprox<float> compApprox(tolerance);
+  MLCommon::CompareApprox<float> compApprox(tolerance);
 
   std::vector<metric_t> all_metrics = {
     metric_t::mae, metric_t::mse, metric_t::rmse, metric_t::pearson, metric_t::spearman};
diff --git a/cpp/test/sg/hdbscan_test.cu b/cpp/test/sg/hdbscan_test.cu
index 17d86a4a64..e3b5b40b22 100644
--- a/cpp/test/sg/hdbscan_test.cu
+++ b/cpp/test/sg/hdbscan_test.cu
@@ -314,11 +314,11 @@ class ClusterSelectionTest : public ::testing::TestWithParam<ClusterSelectionInp
 
     handle.sync_stream(handle.get_stream());
 
-    ASSERT_TRUE(raft::devArrMatch(probabilities.data(),
-                                  params.probabilities.data(),
-                                  params.n_row,
-                                  raft::CompareApprox<float>(1e-4),
-                                  handle.get_stream()));
+    ASSERT_TRUE(MLCommon::devArrMatch(probabilities.data(),
+                                      params.probabilities.data(),
+                                      params.n_row,
+                                      MLCommon::CompareApprox<float>(1e-4),
+                                      handle.get_stream()));
 
     rmm::device_uvector<IdxT> labels_ref(params.n_row, handle.get_stream());
     raft::update_device(labels_ref.data(), params.labels.data(), params.n_row, handle.get_stream());
@@ -460,11 +460,11 @@ class SoftClusteringTest : public ::testing::TestWithParam<SoftClusteringInputs<
                                               raft::distance::DistanceType::L2SqrtExpanded,
                                               membership_vec.data());
 
-    ASSERT_TRUE(raft::devArrMatch(membership_vec.data(),
-                                  params.expected_probabilities.data(),
-                                  params.n_row * n_selected_clusters,
-                                  raft::CompareApprox<float>(1e-5),
-                                  handle.get_stream()));
+    ASSERT_TRUE(MLCommon::devArrMatch(membership_vec.data(),
+                                      params.expected_probabilities.data(),
+                                      params.n_row * n_selected_clusters,
+                                      MLCommon::CompareApprox<float>(1e-5),
+                                      handle.get_stream()));
   }
 
   void SetUp() override { basicTest(); }
@@ -607,17 +607,17 @@ class ApproximatePredictTest : public ::testing::TestWithParam<ApproximatePredic
     handle.sync_stream(handle.get_stream());
     cudaDeviceSynchronize();
 
-    ASSERT_TRUE(raft::devArrMatch(out_labels.data(),
-                                  params.expected_labels.data(),
-                                  params.n_points_to_predict,
-                                  raft::Compare<int>(),
-                                  handle.get_stream()));
-
-    ASSERT_TRUE(raft::devArrMatch(out_probabilities.data(),
-                                  params.expected_probabilities.data(),
-                                  params.n_points_to_predict,
-                                  raft::CompareApprox<float>(1e-2),
-                                  handle.get_stream()));
+    ASSERT_TRUE(MLCommon::devArrMatch(out_labels.data(),
+                                      params.expected_labels.data(),
+                                      params.n_points_to_predict,
+                                      MLCommon::Compare<int>(),
+                                      handle.get_stream()));
+
+    ASSERT_TRUE(MLCommon::devArrMatch(out_probabilities.data(),
+                                      params.expected_probabilities.data(),
+                                      params.n_points_to_predict,
+                                      MLCommon::CompareApprox<float>(1e-2),
+                                      handle.get_stream()));
   }
 
   void SetUp() override { basicTest(); }
diff --git a/cpp/test/sg/holtwinters_test.cu b/cpp/test/sg/holtwinters_test.cu
index c16b09e08b..b0285bc732 100644
--- a/cpp/test/sg/holtwinters_test.cu
+++ b/cpp/test/sg/holtwinters_test.cu
@@ -21,6 +21,7 @@
 #include <gtest/gtest.h>
 #include <raft/core/cudart_utils.hpp>
 #include <raft/core/handle.hpp>
+#include <raft/core/math.hpp>
 #include <raft/cuda_utils.cuh>
 #include <rmm/device_uvector.hpp>
 #include <test_utils.h>
diff --git a/cpp/test/sg/knn_test.cu b/cpp/test/sg/knn_test.cu
index ae879b0675..970e1f353f 100644
--- a/cpp/test/sg/knn_test.cu
+++ b/cpp/test/sg/knn_test.cu
@@ -188,7 +188,7 @@ class KNNTest : public ::testing::TestWithParam<KNNInputs> {
     ASSERT_TRUE(devArrMatch(expected_labels.data(),
                             actual_labels.data(),
                             params.n_query_row * params.n_neighbors,
-                            raft::Compare<int>()));
+                            MLCommon::Compare<int>()));
   }
 
   void testClassification()
@@ -226,7 +226,7 @@ class KNNTest : public ::testing::TestWithParam<KNNInputs> {
                  params.n_neighbors);
 
     ASSERT_TRUE(devArrMatch(
-      search_labels.data(), actual_labels.data(), params.n_query_row, raft::Compare<int>()));
+      search_labels.data(), actual_labels.data(), params.n_query_row, MLCommon::Compare<int>()));
   }
 
   void testRegression()
@@ -274,10 +274,10 @@ class KNNTest : public ::testing::TestWithParam<KNNInputs> {
                 params.n_query_row,
                 params.n_neighbors);
 
-    ASSERT_TRUE(raft::devArrMatch(query_labels_float.data(),
-                                  actual_labels_float.data(),
-                                  params.n_query_row,
-                                  raft::Compare<float>()));
+    ASSERT_TRUE(MLCommon::devArrMatch(query_labels_float.data(),
+                                      actual_labels_float.data(),
+                                      params.n_query_row,
+                                      MLCommon::Compare<float>()));
   }
 
  private:
diff --git a/cpp/test/sg/lars_test.cu b/cpp/test/sg/lars_test.cu
index 7d852d9354..3a559ba5fc 100644
--- a/cpp/test/sg/lars_test.cu
+++ b/cpp/test/sg/lars_test.cu
@@ -80,11 +80,11 @@ class LarsTest : public ::testing::Test {
     EXPECT_EQ(n_active, 3);
 
     EXPECT_TRUE(
-      raft::devArrMatchHost(cor_exp, cor.data(), n_cols, raft::Compare<math_t>(), stream));
-    EXPECT_TRUE(
-      raft::devArrMatchHost(G_exp, G.data(), n_cols * n_cols, raft::Compare<math_t>(), stream));
-    EXPECT_TRUE(raft::devArrMatch(
-      (math_t)1.0, sign.data() + n_active - 1, 1, raft::Compare<math_t>(), stream));
+      MLCommon::devArrMatchHost(cor_exp, cor.data(), n_cols, MLCommon::Compare<math_t>(), stream));
+    EXPECT_TRUE(MLCommon::devArrMatchHost(
+      G_exp, G.data(), n_cols * n_cols, MLCommon::Compare<math_t>(), stream));
+    EXPECT_TRUE(MLCommon::devArrMatch(
+      (math_t)1.0, sign.data() + n_active - 1, 1, MLCommon::Compare<math_t>(), stream));
 
     // Do it again with G == nullptr to test if X is properly changed
     n_active = 2;
@@ -101,8 +101,8 @@ class LarsTest : public ::testing::Test {
                                    n_cols,
                                    sign.data(),
                                    stream);
-    EXPECT_TRUE(
-      raft::devArrMatchHost(X_exp, X.data(), n_rows * n_cols, raft::Compare<math_t>(), stream));
+    EXPECT_TRUE(MLCommon::devArrMatchHost(
+      X_exp, X.data(), n_rows * n_cols, MLCommon::Compare<math_t>(), stream));
   }
 
   void calcUExp(math_t* G, int n_cols, math_t* U_dev_exp)
@@ -178,8 +178,8 @@ class LarsTest : public ::testing::Test {
                                      workspace,
                                      eps,
                                      stream);
-    EXPECT_TRUE(raft::devArrMatch(
-      U_dev_exp.data(), U.data(), n_cols * n_cols, raft::CompareApprox<math_t>(1e-5), stream));
+    EXPECT_TRUE(MLCommon::devArrMatch(
+      U_dev_exp.data(), U.data(), n_cols * n_cols, MLCommon::CompareApprox<math_t>(1e-5), stream));
 
     // Next test where G and U are separate arrays
     initGU(U.data(), G.data(), U_dev_exp.data(), n_active, false);
@@ -196,8 +196,8 @@ class LarsTest : public ::testing::Test {
                                      workspace,
                                      eps,
                                      stream);
-    EXPECT_TRUE(raft::devArrMatch(
-      U_dev_exp.data(), U.data(), n_cols * n_cols, raft::CompareApprox<math_t>(1e-5), stream));
+    EXPECT_TRUE(MLCommon::devArrMatch(
+      U_dev_exp.data(), U.data(), n_cols * n_cols, MLCommon::CompareApprox<math_t>(1e-5), stream));
 
     // Third test without Gram matrix.
     initGU(U.data(), G.data(), U_dev_exp.data(), n_active, false);
@@ -214,8 +214,8 @@ class LarsTest : public ::testing::Test {
                                      workspace,
                                      eps,
                                      stream);
-    EXPECT_TRUE(raft::devArrMatch(
-      U_dev_exp.data(), U.data(), n_cols * n_cols, raft::CompareApprox<math_t>(1e-4), stream));
+    EXPECT_TRUE(MLCommon::devArrMatch(
+      U_dev_exp.data(), U.data(), n_cols * n_cols, MLCommon::CompareApprox<math_t>(1e-4), stream));
   }
 
   void testCalcW0()
@@ -229,8 +229,8 @@ class LarsTest : public ::testing::Test {
 
     ML::Solver::Lars::calcW0(
       handle, n_active, n_cols, sign.data(), U.data(), ld_U, ws.data(), stream);
-    EXPECT_TRUE(raft::devArrMatchHost(
-      ws0_exp, ws.data(), n_active, raft::CompareApprox<math_t>(1e-3), stream));
+    EXPECT_TRUE(MLCommon::devArrMatchHost(
+      ws0_exp, ws.data(), n_active, MLCommon::CompareApprox<math_t>(1e-3), stream));
   }
 
   void testCalcA()
@@ -241,8 +241,8 @@ class LarsTest : public ::testing::Test {
     raft::update_device(ws.data(), ws0_exp, n_active, stream);
 
     ML::Solver::Lars::calcA(handle, A.data(), n_active, sign.data(), ws.data(), stream);
-    EXPECT_TRUE(raft::devArrMatch(
-      (math_t)0.20070615686577709, A.data(), 1, raft::CompareApprox<math_t>(1e-6), stream));
+    EXPECT_TRUE(MLCommon::devArrMatch(
+      (math_t)0.20070615686577709, A.data(), 1, MLCommon::CompareApprox<math_t>(1e-6), stream));
   }
 
   void testEquiangular()
@@ -275,11 +275,11 @@ class LarsTest : public ::testing::Test {
                                          (math_t)-1,
                                          stream);
 
-    EXPECT_TRUE(raft::devArrMatchHost(
-      ws_exp, ws.data(), n_active, raft::CompareApprox<math_t>(1e-3), stream));
+    EXPECT_TRUE(MLCommon::devArrMatchHost(
+      ws_exp, ws.data(), n_active, MLCommon::CompareApprox<math_t>(1e-3), stream));
 
-    EXPECT_TRUE(raft::devArrMatch(
-      (math_t)0.20070615686577709, A.data(), 1, raft::CompareApprox<math_t>(1e-4), stream));
+    EXPECT_TRUE(MLCommon::devArrMatch(
+      (math_t)0.20070615686577709, A.data(), 1, MLCommon::CompareApprox<math_t>(1e-4), stream));
 
     // Now test without Gram matrix, u should be calculated in this case
     initGU(G.data(), G.data(), U.data(), n_active, false);
@@ -301,8 +301,8 @@ class LarsTest : public ::testing::Test {
                                          (math_t)-1,
                                          stream);
 
-    EXPECT_TRUE(
-      raft::devArrMatchHost(u_eq_exp, u_eq.data(), 1, raft::CompareApprox<math_t>(1e-3), stream));
+    EXPECT_TRUE(MLCommon::devArrMatchHost(
+      u_eq_exp, u_eq.data(), 1, MLCommon::CompareApprox<math_t>(1e-3), stream));
   }
 
   void testCalcMaxStep()
@@ -345,11 +345,11 @@ class LarsTest : public ::testing::Test {
                                   a_vec.data(),
                                   stream);
     math_t gamma_exp = 0.20095407186830386;
-    EXPECT_TRUE(
-      raft::devArrMatch(gamma_exp, gamma.data(), 1, raft::CompareApprox<math_t>(1e-6), stream));
+    EXPECT_TRUE(MLCommon::devArrMatch(
+      gamma_exp, gamma.data(), 1, MLCommon::CompareApprox<math_t>(1e-6), stream));
     math_t a_vec_exp[2] = {24.69447886, -139.66289908};
-    EXPECT_TRUE(raft::devArrMatchHost(
-      a_vec_exp, a_vec.data(), a_vec.size(), raft::CompareApprox<math_t>(1e-4), stream));
+    EXPECT_TRUE(MLCommon::devArrMatchHost(
+      a_vec_exp, a_vec.data(), a_vec.size(), MLCommon::CompareApprox<math_t>(1e-4), stream));
 
     // test without G matrix, we use U as input in this case
     RAFT_CUDA_TRY(cudaMemsetAsync(gamma.data(), 0, sizeof(math_t), stream));
@@ -371,10 +371,10 @@ class LarsTest : public ::testing::Test {
                                   gamma.data(),
                                   a_vec.data(),
                                   stream);
-    EXPECT_TRUE(
-      raft::devArrMatch(gamma_exp, gamma.data(), 1, raft::CompareApprox<math_t>(1e-6), stream));
-    EXPECT_TRUE(raft::devArrMatchHost(
-      a_vec_exp, a_vec.data(), a_vec.size(), raft::CompareApprox<math_t>(1e-4), stream));
+    EXPECT_TRUE(MLCommon::devArrMatch(
+      gamma_exp, gamma.data(), 1, MLCommon::CompareApprox<math_t>(1e-6), stream));
+    EXPECT_TRUE(MLCommon::devArrMatchHost(
+      a_vec_exp, a_vec.data(), a_vec.size(), MLCommon::CompareApprox<math_t>(1e-4), stream));
 
     // Last iteration
     n_active = max_iter;
@@ -397,8 +397,8 @@ class LarsTest : public ::testing::Test {
                                   a_vec.data(),
                                   stream);
     gamma_exp = 11.496044516528272;
-    EXPECT_TRUE(
-      raft::devArrMatch(gamma_exp, gamma.data(), 1, raft::CompareApprox<math_t>(1e-6), stream));
+    EXPECT_TRUE(MLCommon::devArrMatch(
+      gamma_exp, gamma.data(), 1, MLCommon::CompareApprox<math_t>(1e-6), stream));
   }
 
   raft::handle_t handle;
@@ -497,12 +497,12 @@ class LarsTestFitPredict : public ::testing::Test {
                               n_cols,
                               (math_t)-1);
     EXPECT_EQ(n_cols, n_active);
-    EXPECT_TRUE(raft::devArrMatchHost(
-      beta_exp, beta.data(), n_cols, raft::CompareApprox<math_t>(1e-5), stream));
-    EXPECT_TRUE(raft::devArrMatchHost(
-      alphas_exp, alphas.data(), n_cols + 1, raft::CompareApprox<math_t>(1e-4), stream));
-    EXPECT_TRUE(
-      raft::devArrMatchHost(indices_exp, active_idx.data(), n_cols, raft::Compare<int>(), stream));
+    EXPECT_TRUE(MLCommon::devArrMatchHost(
+      beta_exp, beta.data(), n_cols, MLCommon::CompareApprox<math_t>(1e-5), stream));
+    EXPECT_TRUE(MLCommon::devArrMatchHost(
+      alphas_exp, alphas.data(), n_cols + 1, MLCommon::CompareApprox<math_t>(1e-4), stream));
+    EXPECT_TRUE(MLCommon::devArrMatchHost(
+      indices_exp, active_idx.data(), n_cols, MLCommon::Compare<int>(), stream));
   }
 
   void testFitX()
@@ -528,12 +528,12 @@ class LarsTestFitPredict : public ::testing::Test {
                               n_cols,
                               (math_t)-1);
     EXPECT_EQ(n_cols, n_active);
-    EXPECT_TRUE(raft::devArrMatchHost(
-      beta_exp, beta.data(), n_cols, raft::CompareApprox<math_t>(2e-4), stream));
-    EXPECT_TRUE(raft::devArrMatchHost(
-      alphas_exp, alphas.data(), n_cols + 1, raft::CompareApprox<math_t>(1e-4), stream));
-    EXPECT_TRUE(
-      raft::devArrMatchHost(indices_exp, active_idx.data(), n_cols, raft::Compare<int>(), stream));
+    EXPECT_TRUE(MLCommon::devArrMatchHost(
+      beta_exp, beta.data(), n_cols, MLCommon::CompareApprox<math_t>(2e-4), stream));
+    EXPECT_TRUE(MLCommon::devArrMatchHost(
+      alphas_exp, alphas.data(), n_cols + 1, MLCommon::CompareApprox<math_t>(1e-4), stream));
+    EXPECT_TRUE(MLCommon::devArrMatchHost(
+      indices_exp, active_idx.data(), n_cols, MLCommon::Compare<int>(), stream));
   }
 
   void testPredictV1()
@@ -555,8 +555,8 @@ class LarsTestFitPredict : public ::testing::Test {
                                   active_idx.data(),
                                   intercept,
                                   y.data());
-    EXPECT_TRUE(
-      raft::devArrMatchHost(pred_exp, y.data(), n_rows, raft::CompareApprox<math_t>(1e-5), stream));
+    EXPECT_TRUE(MLCommon::devArrMatchHost(
+      pred_exp, y.data(), n_rows, MLCommon::CompareApprox<math_t>(1e-5), stream));
   }
 
   void testPredictV2()
@@ -582,8 +582,8 @@ class LarsTestFitPredict : public ::testing::Test {
                                   active_idx.data(),
                                   intercept,
                                   y.data());
-    EXPECT_TRUE(
-      raft::devArrMatchHost(pred_exp, y.data(), n_rows, raft::CompareApprox<math_t>(1e-5), stream));
+    EXPECT_TRUE(MLCommon::devArrMatchHost(
+      pred_exp, y.data(), n_rows, MLCommon::CompareApprox<math_t>(1e-5), stream));
   }
 
   void testFitLarge()
diff --git a/cpp/test/sg/linkage_test.cu b/cpp/test/sg/linkage_test.cu
index e0892104e7..3977968d52 100644
--- a/cpp/test/sg/linkage_test.cu
+++ b/cpp/test/sg/linkage_test.cu
@@ -341,8 +341,8 @@ const std::vector<LinkageInputs<float, int>> linkage_inputsf2 = {
 typedef LinkageTest<float, int> LinkageTestF_Int;
 TEST_P(LinkageTestF_Int, Result)
 {
-  EXPECT_TRUE(
-    raft::devArrMatch(labels.data(), labels_ref.data(), params.n_row, raft::Compare<int>()));
+  EXPECT_TRUE(MLCommon::devArrMatch(
+    labels.data(), labels_ref.data(), params.n_row, MLCommon::Compare<int>()));
 }
 
 INSTANTIATE_TEST_CASE_P(LinkageTest, LinkageTestF_Int, ::testing::ValuesIn(linkage_inputsf2));
diff --git a/cpp/test/sg/ols.cu b/cpp/test/sg/ols.cu
index b5db4b14d1..18d57426ed 100644
--- a/cpp/test/sg/ols.cu
+++ b/cpp/test/sg/ols.cu
@@ -252,50 +252,54 @@ typedef OlsTest<float> OlsTestF;
 TEST_P(OlsTestF, Fit)
 {
   ASSERT_TRUE(devArrMatch(
-    coef_ref.data(), coef.data(), params.n_col, raft::CompareApproxAbs<float>(params.tol)));
+    coef_ref.data(), coef.data(), params.n_col, MLCommon::CompareApproxAbs<float>(params.tol)));
 
   ASSERT_TRUE(devArrMatch(
-    coef2_ref.data(), coef2.data(), params.n_col, raft::CompareApproxAbs<float>(params.tol)));
+    coef2_ref.data(), coef2.data(), params.n_col, MLCommon::CompareApproxAbs<float>(params.tol)));
 
   ASSERT_TRUE(devArrMatch(
-    coef3_ref.data(), coef3.data(), params.n_col, raft::CompareApproxAbs<float>(params.tol)));
+    coef3_ref.data(), coef3.data(), params.n_col, MLCommon::CompareApproxAbs<float>(params.tol)));
 
   ASSERT_TRUE(devArrMatch(
-    pred_ref.data(), pred.data(), params.n_row_2, raft::CompareApproxAbs<float>(params.tol)));
+    pred_ref.data(), pred.data(), params.n_row_2, MLCommon::CompareApproxAbs<float>(params.tol)));
 
   ASSERT_TRUE(devArrMatch(
-    pred2_ref.data(), pred2.data(), params.n_row_2, raft::CompareApproxAbs<float>(params.tol)));
+    pred2_ref.data(), pred2.data(), params.n_row_2, MLCommon::CompareApproxAbs<float>(params.tol)));
 
   ASSERT_TRUE(devArrMatch(
-    pred3_ref.data(), pred3.data(), params.n_row_2, raft::CompareApproxAbs<float>(params.tol)));
+    pred3_ref.data(), pred3.data(), params.n_row_2, MLCommon::CompareApproxAbs<float>(params.tol)));
 
-  ASSERT_TRUE(
-    devArrMatch(coef_sc_ref.data(), coef_sc.data(), 1, raft::CompareApproxAbs<float>(params.tol)));
+  ASSERT_TRUE(devArrMatch(
+    coef_sc_ref.data(), coef_sc.data(), 1, MLCommon::CompareApproxAbs<float>(params.tol)));
 }
 
 typedef OlsTest<double> OlsTestD;
 TEST_P(OlsTestD, Fit)
 {
-  ASSERT_TRUE(raft::devArrMatch(
-    coef_ref.data(), coef.data(), params.n_col, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef_ref.data(), coef.data(), params.n_col, MLCommon::CompareApproxAbs<double>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef2_ref.data(), coef2.data(), params.n_col, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef2_ref.data(), coef2.data(), params.n_col, MLCommon::CompareApproxAbs<double>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef3_ref.data(), coef3.data(), params.n_col, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef3_ref.data(), coef3.data(), params.n_col, MLCommon::CompareApproxAbs<double>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    pred_ref.data(), pred.data(), params.n_row_2, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    pred_ref.data(), pred.data(), params.n_row_2, MLCommon::CompareApproxAbs<double>(params.tol)));
 
-  ASSERT_TRUE(devArrMatch(
-    pred2_ref.data(), pred2.data(), params.n_row_2, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(devArrMatch(pred2_ref.data(),
+                          pred2.data(),
+                          params.n_row_2,
+                          MLCommon::CompareApproxAbs<double>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    pred3_ref.data(), pred3.data(), params.n_row_2, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(pred3_ref.data(),
+                                    pred3.data(),
+                                    params.n_row_2,
+                                    MLCommon::CompareApproxAbs<double>(params.tol)));
 
-  ASSERT_TRUE(
-    devArrMatch(coef_sc_ref.data(), coef_sc.data(), 1, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(devArrMatch(
+    coef_sc_ref.data(), coef_sc.data(), 1, MLCommon::CompareApproxAbs<double>(params.tol)));
 }
 
 INSTANTIATE_TEST_CASE_P(OlsTests, OlsTestF, ::testing::ValuesIn(inputsf2));
diff --git a/cpp/test/sg/pca_test.cu b/cpp/test/sg/pca_test.cu
index edfb361c3e..612dcef325 100644
--- a/cpp/test/sg/pca_test.cu
+++ b/cpp/test/sg/pca_test.cu
@@ -204,7 +204,7 @@ TEST_P(PcaTestValF, Result)
   ASSERT_TRUE(devArrMatch(explained_vars.data(),
                           explained_vars_ref.data(),
                           params.n_col,
-                          raft::CompareApproxAbs<float>(params.tolerance),
+                          MLCommon::CompareApproxAbs<float>(params.tolerance),
                           handle.get_stream()));
 }
 
@@ -214,7 +214,7 @@ TEST_P(PcaTestValD, Result)
   ASSERT_TRUE(devArrMatch(explained_vars.data(),
                           explained_vars_ref.data(),
                           params.n_col,
-                          raft::CompareApproxAbs<double>(params.tolerance),
+                          MLCommon::CompareApproxAbs<double>(params.tolerance),
                           handle.get_stream()));
 }
 
@@ -224,7 +224,7 @@ TEST_P(PcaTestLeftVecF, Result)
   ASSERT_TRUE(devArrMatch(components.data(),
                           components_ref.data(),
                           (params.n_col * params.n_col),
-                          raft::CompareApproxAbs<float>(params.tolerance),
+                          MLCommon::CompareApproxAbs<float>(params.tolerance),
                           handle.get_stream()));
 }
 
@@ -234,7 +234,7 @@ TEST_P(PcaTestLeftVecD, Result)
   ASSERT_TRUE(devArrMatch(components.data(),
                           components_ref.data(),
                           (params.n_col * params.n_col),
-                          raft::CompareApproxAbs<double>(params.tolerance),
+                          MLCommon::CompareApproxAbs<double>(params.tolerance),
                           handle.get_stream()));
 }
 
@@ -244,7 +244,7 @@ TEST_P(PcaTestTransDataF, Result)
   ASSERT_TRUE(devArrMatch(trans_data.data(),
                           trans_data_ref.data(),
                           (params.n_row * params.n_col),
-                          raft::CompareApproxAbs<float>(params.tolerance),
+                          MLCommon::CompareApproxAbs<float>(params.tolerance),
                           handle.get_stream()));
 }
 
@@ -254,7 +254,7 @@ TEST_P(PcaTestTransDataD, Result)
   ASSERT_TRUE(devArrMatch(trans_data.data(),
                           trans_data_ref.data(),
                           (params.n_row * params.n_col),
-                          raft::CompareApproxAbs<double>(params.tolerance),
+                          MLCommon::CompareApproxAbs<double>(params.tolerance),
                           handle.get_stream()));
 }
 
@@ -264,7 +264,7 @@ TEST_P(PcaTestDataVecSmallF, Result)
   ASSERT_TRUE(devArrMatch(data.data(),
                           data_back.data(),
                           (params.n_col * params.n_col),
-                          raft::CompareApproxAbs<float>(params.tolerance),
+                          MLCommon::CompareApproxAbs<float>(params.tolerance),
                           handle.get_stream()));
 }
 
@@ -274,7 +274,7 @@ TEST_P(PcaTestDataVecSmallD, Result)
   ASSERT_TRUE(devArrMatch(data.data(),
                           data_back.data(),
                           (params.n_col * params.n_col),
-                          raft::CompareApproxAbs<double>(params.tolerance),
+                          MLCommon::CompareApproxAbs<double>(params.tolerance),
                           handle.get_stream()));
 }
 
@@ -286,18 +286,18 @@ TEST_P(PcaTestDataVecF, Result)
   ASSERT_TRUE(devArrMatch(data2.data(),
                           data2_back.data(),
                           (params.n_col2 * params.n_col2),
-                          raft::CompareApproxAbs<float>(params.tolerance),
+                          MLCommon::CompareApproxAbs<float>(params.tolerance),
                           handle.get_stream()));
 }
 
 typedef PcaTest<double> PcaTestDataVecD;
 TEST_P(PcaTestDataVecD, Result)
 {
-  ASSERT_TRUE(raft::devArrMatch(data2.data(),
-                                data2_back.data(),
-                                (params.n_col2 * params.n_col2),
-                                raft::CompareApproxAbs<double>(params.tolerance),
-                                handle.get_stream()));
+  ASSERT_TRUE(MLCommon::devArrMatch(data2.data(),
+                                    data2_back.data(),
+                                    (params.n_col2 * params.n_col2),
+                                    MLCommon::CompareApproxAbs<double>(params.tolerance),
+                                    handle.get_stream()));
 }
 
 INSTANTIATE_TEST_CASE_P(PcaTests, PcaTestValF, ::testing::ValuesIn(inputsf2));
diff --git a/cpp/test/sg/quasi_newton.cu b/cpp/test/sg/quasi_newton.cu
index 3cb0668e7d..3edc054d76 100644
--- a/cpp/test/sg/quasi_newton.cu
+++ b/cpp/test/sg/quasi_newton.cu
@@ -92,7 +92,7 @@ template <typename T, class Comp>
   raft::update_device(w_ref.data, &w_ref_cm[0], C * D, stream);
   if (fit_intercept) { raft::update_device(&w_ref.data[C * D], host_bias, C, stream); }
   handle.sync_stream(stream);
-  return raft::devArrMatch(w_ref.data, w, w_ref.len, comp);
+  return MLCommon::devArrMatch(w_ref.data, w, w_ref.len, comp);
 }
 
 template <typename T, class LossFunction>
@@ -197,7 +197,7 @@ TEST_F(QuasiNewtonTest, binary_logistic_vs_sklearn)
 #if CUDART_VERSION >= 11020
   GTEST_SKIP();
 #endif
-  raft::CompareApprox<double> compApprox(tol);
+  MLCommon::CompareApprox<double> compApprox(tol);
   // Test case generated in python and solved with sklearn
   double y[N] = {1, 1, 1, 0, 1, 0, 1, 0, 1, 0};
   raft::update_device(ydev->data, &y[0], ydev->len, stream);
@@ -319,7 +319,7 @@ TEST_F(QuasiNewtonTest, multiclass_logistic_vs_sklearn)
   // The data seems to small for the objective to be strongly convex
   // leaving out exact param checks
 
-  raft::CompareApprox<double> compApprox(tol);
+  MLCommon::CompareApprox<double> compApprox(tol);
   double y[N] = {2, 2, 0, 3, 3, 0, 0, 0, 1, 0};
   raft::update_device(ydev->data, &y[0], ydev->len, stream);
   handle.sync_stream(stream);
@@ -423,7 +423,7 @@ TEST_F(QuasiNewtonTest, multiclass_logistic_vs_sklearn)
 
 TEST_F(QuasiNewtonTest, linear_regression_vs_sklearn)
 {
-  raft::CompareApprox<double> compApprox(tol);
+  MLCommon::CompareApprox<double> compApprox(tol);
   double y[N] = {0.2675836026202781,
                  -0.0678277759663704,
                  -0.6334027174275105,
@@ -543,7 +543,7 @@ TEST_F(QuasiNewtonTest, linear_regression_vs_sklearn)
 
 TEST_F(QuasiNewtonTest, predict)
 {
-  raft::CompareApprox<double> compApprox(1e-8);
+  MLCommon::CompareApprox<double> compApprox(1e-8);
   std::vector<double> w_host(D);
   w_host[0] = 1;
   std::vector<double> preds_host(N);
@@ -576,7 +576,7 @@ TEST_F(QuasiNewtonTest, predict)
 
 TEST_F(QuasiNewtonTest, predict_softmax)
 {
-  raft::CompareApprox<double> compApprox(1e-8);
+  MLCommon::CompareApprox<double> compApprox(1e-8);
   int C = 4;
   std::vector<double> w_host(C * D);
   w_host[0]         = 1;
@@ -631,7 +631,7 @@ TEST_F(QuasiNewtonTest, dense_vs_sparse_logistic)
   SimpleSparseMat<double> X_sparse(
     Xdev->data, mem_X_cols.data(), mem_X_row_ids.data(), N * D, N, D);
 
-  raft::CompareApprox<double> compApprox(tol);
+  MLCommon::CompareApprox<double> compApprox(tol);
   double y[N] = {2, 2, 0, 3, 3, 0, 0, 0, 1, 0};
   raft::update_device(ydev->data, &y[0], ydev->len, stream);
   handle.sync_stream(stream);
diff --git a/cpp/test/sg/ridge.cu b/cpp/test/sg/ridge.cu
index 8b9fdc4de9..8e742c643e 100644
--- a/cpp/test/sg/ridge.cu
+++ b/cpp/test/sg/ridge.cu
@@ -293,57 +293,61 @@ const std::vector<RidgeInputs<double>> inputsd2 = {{0.001, 3, 2, 2, 0, 0.5},
 typedef RidgeTest<float> RidgeTestF;
 TEST_P(RidgeTestF, Fit)
 {
-  ASSERT_TRUE(raft::devArrMatch(
-    coef_ref.data(), coef.data(), params.n_col, raft::CompareApproxAbs<float>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef_ref.data(), coef.data(), params.n_col, MLCommon::CompareApproxAbs<float>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef2_ref.data(), coef2.data(), params.n_col, raft::CompareApproxAbs<float>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef2_ref.data(), coef2.data(), params.n_col, MLCommon::CompareApproxAbs<float>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef3_ref.data(), coef3.data(), params.n_col, raft::CompareApproxAbs<float>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef3_ref.data(), coef3.data(), params.n_col, MLCommon::CompareApproxAbs<float>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    pred_ref.data(), pred.data(), params.n_row_2, raft::CompareApproxAbs<float>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    pred_ref.data(), pred.data(), params.n_row_2, MLCommon::CompareApproxAbs<float>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    pred2_ref.data(), pred2.data(), params.n_row_2, raft::CompareApproxAbs<float>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    pred2_ref.data(), pred2.data(), params.n_row_2, MLCommon::CompareApproxAbs<float>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    pred3_ref.data(), pred3.data(), params.n_row_2, raft::CompareApproxAbs<float>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    pred3_ref.data(), pred3.data(), params.n_row_2, MLCommon::CompareApproxAbs<float>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef_sc_ref.data(), coef_sc.data(), 1, raft::CompareApproxAbs<float>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef_sc_ref.data(), coef_sc.data(), 1, MLCommon::CompareApproxAbs<float>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef_sw_ref.data(), coef_sw.data(), 1, raft::CompareApproxAbs<float>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef_sw_ref.data(), coef_sw.data(), 1, MLCommon::CompareApproxAbs<float>(params.tol)));
 }
 
 typedef RidgeTest<double> RidgeTestD;
 TEST_P(RidgeTestD, Fit)
 {
-  ASSERT_TRUE(raft::devArrMatch(
-    coef_ref.data(), coef.data(), params.n_col, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef_ref.data(), coef.data(), params.n_col, MLCommon::CompareApproxAbs<double>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef2_ref.data(), coef2.data(), params.n_col, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef2_ref.data(), coef2.data(), params.n_col, MLCommon::CompareApproxAbs<double>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef3_ref.data(), coef3.data(), params.n_col, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef3_ref.data(), coef3.data(), params.n_col, MLCommon::CompareApproxAbs<double>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    pred_ref.data(), pred.data(), params.n_row_2, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    pred_ref.data(), pred.data(), params.n_row_2, MLCommon::CompareApproxAbs<double>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    pred2_ref.data(), pred2.data(), params.n_row_2, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(pred2_ref.data(),
+                                    pred2.data(),
+                                    params.n_row_2,
+                                    MLCommon::CompareApproxAbs<double>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    pred3_ref.data(), pred3.data(), params.n_row_2, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(pred3_ref.data(),
+                                    pred3.data(),
+                                    params.n_row_2,
+                                    MLCommon::CompareApproxAbs<double>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef_sc_ref.data(), coef_sc.data(), 1, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef_sc_ref.data(), coef_sc.data(), 1, MLCommon::CompareApproxAbs<double>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef_sw_ref.data(), coef_sw.data(), 1, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef_sw_ref.data(), coef_sw.data(), 1, MLCommon::CompareApproxAbs<double>(params.tol)));
 }
 
 INSTANTIATE_TEST_CASE_P(RidgeTests, RidgeTestF, ::testing::ValuesIn(inputsf2));
diff --git a/cpp/test/sg/sgd.cu b/cpp/test/sg/sgd.cu
index afe2f7ee66..2a7ad4c747 100644
--- a/cpp/test/sg/sgd.cu
+++ b/cpp/test/sg/sgd.cu
@@ -298,37 +298,41 @@ const std::vector<SgdInputs<double>> inputsd2 = {{0.01, 4, 2, 4, 3, 2}};
 typedef SgdTest<float> SgdTestF;
 TEST_P(SgdTestF, Fit)
 {
-  ASSERT_TRUE(raft::devArrMatch(
-    coef_ref.data(), coef.data(), params.n_col, raft::CompareApproxAbs<float>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef_ref.data(), coef.data(), params.n_col, MLCommon::CompareApproxAbs<float>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef2_ref.data(), coef2.data(), params.n_col, raft::CompareApproxAbs<float>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef2_ref.data(), coef2.data(), params.n_col, MLCommon::CompareApproxAbs<float>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    pred_log_ref.data(), pred_log.data(), params.n_row, raft::CompareApproxAbs<float>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(pred_log_ref.data(),
+                                    pred_log.data(),
+                                    params.n_row,
+                                    MLCommon::CompareApproxAbs<float>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    pred_svm_ref.data(), pred_svm.data(), params.n_row, raft::CompareApproxAbs<float>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(pred_svm_ref.data(),
+                                    pred_svm.data(),
+                                    params.n_row,
+                                    MLCommon::CompareApproxAbs<float>(params.tol)));
 }
 
 typedef SgdTest<double> SgdTestD;
 TEST_P(SgdTestD, Fit)
 {
-  ASSERT_TRUE(raft::devArrMatch(
-    coef_ref.data(), coef.data(), params.n_col, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef_ref.data(), coef.data(), params.n_col, MLCommon::CompareApproxAbs<double>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(
-    coef2_ref.data(), coef2.data(), params.n_col, raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(
+    coef2_ref.data(), coef2.data(), params.n_col, MLCommon::CompareApproxAbs<double>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(pred_log_ref.data(),
-                                pred_log.data(),
-                                params.n_row,
-                                raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(pred_log_ref.data(),
+                                    pred_log.data(),
+                                    params.n_row,
+                                    MLCommon::CompareApproxAbs<double>(params.tol)));
 
-  ASSERT_TRUE(raft::devArrMatch(pred_svm_ref.data(),
-                                pred_svm.data(),
-                                params.n_row,
-                                raft::CompareApproxAbs<double>(params.tol)));
+  ASSERT_TRUE(MLCommon::devArrMatch(pred_svm_ref.data(),
+                                    pred_svm.data(),
+                                    params.n_row,
+                                    MLCommon::CompareApproxAbs<double>(params.tol)));
 }
 
 INSTANTIATE_TEST_CASE_P(SgdTests, SgdTestF, ::testing::ValuesIn(inputsf2));
diff --git a/cpp/test/sg/svc_test.cu b/cpp/test/sg/svc_test.cu
index a43be586d2..1d3e48daeb 100644
--- a/cpp/test/sg/svc_test.cu
+++ b/cpp/test/sg/svc_test.cu
@@ -27,6 +27,7 @@
 #include <cuml/svm/svr.hpp>
 #include <gtest/gtest.h>
 #include <iostream>
+#include <raft/core/math.hpp>
 #include <raft/distance/kernels.cuh>
 #include <raft/linalg/add.cuh>
 #include <raft/linalg/map_then_reduce.cuh>
@@ -123,20 +124,26 @@ TYPED_TEST(WorkingSetTest, Select)
   EXPECT_EQ(this->ws->GetSize(), 4);
   this->ws->SimpleSelect(
     this->f_dev.data(), this->alpha_dev.data(), this->y_dev.data(), this->C_dev.data());
-  ASSERT_TRUE(devArrMatchHost(
-    this->expected_idx, this->ws->GetIndices(), this->ws->GetSize(), raft::Compare<int>(), stream));
+  ASSERT_TRUE(devArrMatchHost(this->expected_idx,
+                              this->ws->GetIndices(),
+                              this->ws->GetSize(),
+                              MLCommon::Compare<int>(),
+                              stream));
 
   this->ws->Select(
     this->f_dev.data(), this->alpha_dev.data(), this->y_dev.data(), this->C_dev.data());
-  ASSERT_TRUE(devArrMatchHost(
-    this->expected_idx, this->ws->GetIndices(), this->ws->GetSize(), raft::Compare<int>(), stream));
+  ASSERT_TRUE(devArrMatchHost(this->expected_idx,
+                              this->ws->GetIndices(),
+                              this->ws->GetSize(),
+                              MLCommon::Compare<int>(),
+                              stream));
   this->ws->Select(
     this->f_dev.data(), this->alpha_dev.data(), this->y_dev.data(), this->C_dev.data());
 
   ASSERT_TRUE(devArrMatchHost(this->expected_idx2,
                               this->ws->GetIndices(),
                               this->ws->GetSize(),
-                              raft::Compare<int>(),
+                              MLCommon::Compare<int>(),
                               stream));
   delete this->ws;
 }
@@ -211,8 +218,8 @@ class KernelCacheTest : public ::testing::Test {
       int kidx                = kidx_h[i];
       const math_t* cache_row = tile_dev + kidx * n_rows;
       const math_t* row_exp   = tile_host_all + widx * n_rows;
-      EXPECT_TRUE(
-        devArrMatchHost(row_exp, cache_row, n_rows, raft::CompareApprox<math_t>(1e-6f), stream));
+      EXPECT_TRUE(devArrMatchHost(
+        row_exp, cache_row, n_rows, MLCommon::CompareApprox<math_t>(1e-6f), stream));
     }
   }
 
@@ -261,7 +268,7 @@ TYPED_TEST_P(KernelCacheTest, EvalTest)
     ASSERT_TRUE(devArrMatchHost(this->tile_host_expected,
                                 tile_dev,
                                 this->n_rows * this->n_ws,
-                                raft::CompareApprox<TypeParam>(1e-6f),
+                                MLCommon::CompareApprox<TypeParam>(1e-6f),
                                 stream));
     delete kernel;
   }
@@ -347,14 +354,14 @@ class GetResultsTest : public ::testing::Test {
 
     math_t dual_coefs_exp[] = {-0.1, -0.2, -1.5, 0.2, 0.4, 1.5, 1.5};
     EXPECT_TRUE(devArrMatchHost(
-      dual_coefs_exp, dual_coefs, n_coefs, raft::CompareApprox<math_t>(1e-6f), stream));
+      dual_coefs_exp, dual_coefs, n_coefs, MLCommon::CompareApprox<math_t>(1e-6f), stream));
 
     int idx_exp[] = {2, 3, 4, 6, 7, 8, 9};
-    EXPECT_TRUE(devArrMatchHost(idx_exp, idx, n_coefs, raft::Compare<int>(), stream));
+    EXPECT_TRUE(devArrMatchHost(idx_exp, idx, n_coefs, MLCommon::Compare<int>(), stream));
 
     math_t x_support_exp[] = {3, 4, 5, 7, 8, 9, 10, 13, 14, 15, 17, 18, 19, 20};
     EXPECT_TRUE(devArrMatchHost(
-      x_support_exp, x_support, n_coefs * n_cols, raft::CompareApprox<math_t>(1e-6f), stream));
+      x_support_exp, x_support, n_coefs * n_cols, MLCommon::CompareApprox<math_t>(1e-6f), stream));
 
     EXPECT_FLOAT_EQ(b, -6.25f);
 
@@ -426,7 +433,7 @@ class SmoUpdateTest : public ::testing::Test {
     smo.UpdateF(f_dev.data(), n_rows, delta_alpha_dev.data(), n_ws, kernel_dev.data());
 
     float f_host_expected[] = {0.1f, 7.4505806e-9f, 0.3f, 0.2f, 0.5f, 0.4f};
-    devArrMatchHost(f_host_expected, f_dev.data(), n_rows, raft::CompareApprox<math_t>(1e-6));
+    devArrMatchHost(f_host_expected, f_dev.data(), n_rows, MLCommon::CompareApprox<math_t>(1e-6));
   }
 
   raft::handle_t handle;
@@ -491,7 +498,7 @@ class SmoBlockSolverTest : public ::testing::Test {
 
     math_t return_buff_exp[2] = {0.2, 1};
     devArrMatchHost(
-      return_buff_exp, return_buff_dev.data(), 2, raft::CompareApprox<math_t>(1e-6), stream);
+      return_buff_exp, return_buff_dev.data(), 2, MLCommon::CompareApprox<math_t>(1e-6), stream);
 
     rmm::device_uvector<math_t> delta_alpha_calc(n_rows, stream);
     raft::linalg::binaryOp(
@@ -501,14 +508,14 @@ class SmoBlockSolverTest : public ::testing::Test {
       n_rows,
       [] __device__(math_t a, math_t b) { return a * b; },
       stream);
-    raft::devArrMatch(delta_alpha_dev.data(),
-                      delta_alpha_calc.data(),
-                      n_rows,
-                      raft::CompareApprox<math_t>(1e-6),
-                      stream);
+    MLCommon::devArrMatch(delta_alpha_dev.data(),
+                          delta_alpha_calc.data(),
+                          n_rows,
+                          MLCommon::CompareApprox<math_t>(1e-6),
+                          stream);
     math_t alpha_expected[] = {0, 0.1f, 0.1f, 0};
-    raft::devArrMatch(
-      alpha_expected, alpha_dev.data(), n_rows, raft::CompareApprox<math_t>(1e-6), stream);
+    MLCommon::devArrMatch(
+      alpha_expected, alpha_dev.data(), n_rows, MLCommon::CompareApprox<math_t>(1e-6), stream);
   }
 
  protected:
@@ -618,7 +625,7 @@ void checkResults(SvmModel<math_t> model,
   EXPECT_LE(abs(model.n_support - expected.n_support), tol.n_sv);
   if (dcoef_exp) {
     EXPECT_TRUE(devArrMatchHost(
-      dcoef_exp, model.dual_coefs, model.n_support, raft::CompareApprox<math_t>(1e-3f)));
+      dcoef_exp, model.dual_coefs, model.n_support, MLCommon::CompareApprox<math_t>(1e-3f)));
   }
   math_t* dual_coefs_host = new math_t[model.n_support];
   raft::update_host(dual_coefs_host, model.dual_coefs, model.n_support, stream);
@@ -634,13 +641,13 @@ void checkResults(SvmModel<math_t> model,
     EXPECT_TRUE(devArrMatchHost(x_support_exp,
                                 model.x_support,
                                 model.n_support * model.n_cols,
-                                raft::CompareApprox<math_t>(1e-6f),
+                                MLCommon::CompareApprox<math_t>(1e-6f),
                                 stream));
   }
 
   if (idx_exp) {
-    EXPECT_TRUE(
-      devArrMatchHost(idx_exp, model.support_idx, model.n_support, raft::Compare<int>(), stream));
+    EXPECT_TRUE(devArrMatchHost(
+      idx_exp, model.support_idx, model.n_support, MLCommon::Compare<int>(), stream));
   }
 
   math_t* x_support_host = new math_t[model.n_support * model.n_cols];
@@ -742,16 +749,16 @@ class SmoSolverTest : public ::testing::Test {
       n_rows,
       [] __device__(math_t a, math_t b) { return a * b; },
       stream);
-    raft::devArrMatch(delta_alpha_dev.data(),
-                      delta_alpha_calc.data(),
-                      n_rows,
-                      raft::CompareApprox<math_t>(1e-6),
-                      stream);
+    MLCommon::devArrMatch(delta_alpha_dev.data(),
+                          delta_alpha_calc.data(),
+                          n_rows,
+                          MLCommon::CompareApprox<math_t>(1e-6),
+                          stream);
 
     math_t alpha_expected[] = {0.6f, 0, 1, 1, 0, 0.6f};
     // for C=10: {0.25f, 0, 2.25f, 3.75f, 0, 1.75f};
-    raft::devArrMatch(
-      alpha_expected, alpha_dev.data(), n_rows, raft::CompareApprox<math_t>(1e-6), stream);
+    MLCommon::devArrMatch(
+      alpha_expected, alpha_dev.data(), n_rows, MLCommon::CompareApprox<math_t>(1e-6), stream);
 
     math_t host_alpha[6];
     raft::update_host(host_alpha, alpha_dev.data(), n_rows, stream);
@@ -810,11 +817,12 @@ class SmoSolverTest : public ::testing::Test {
     EXPECT_LT(return_buff[1], 10) << return_buff[1];
 
     math_t alpha_exp[] = {0, 0.8, 0.8, 0};
-    raft::devArrMatch(alpha_exp, alpha_dev.data(), 4, raft::CompareApprox<math_t>(1e-6), stream);
+    MLCommon::devArrMatch(
+      alpha_exp, alpha_dev.data(), 4, MLCommon::CompareApprox<math_t>(1e-6), stream);
 
     math_t dalpha_exp[] = {-0.8, 0.8};
-    raft::devArrMatch(
-      dalpha_exp, delta_alpha_dev.data(), 2, raft::CompareApprox<math_t>(1e-6), stream);
+    MLCommon::devArrMatch(
+      dalpha_exp, delta_alpha_dev.data(), 2, MLCommon::CompareApprox<math_t>(1e-6), stream);
   }
 
  protected:
@@ -1015,18 +1023,18 @@ TYPED_TEST(SmoSolverTest, SvcTest)
     rmm::device_uvector<TypeParam> y_pred(p.n_rows, stream);
     if (p.predict) {
       svc.predict(p.x_dev, p.n_rows, p.n_cols, y_pred.data());
-      EXPECT_TRUE(raft::devArrMatch(this->y_dev.data(),
-                                    y_pred.data(),
-                                    p.n_rows,
-                                    raft::CompareApprox<TypeParam>(1e-6f),
-                                    stream));
+      EXPECT_TRUE(MLCommon::devArrMatch(this->y_dev.data(),
+                                        y_pred.data(),
+                                        p.n_rows,
+                                        MLCommon::CompareApprox<TypeParam>(1e-6f),
+                                        stream));
     }
     if (exp.decision_function.size() > 0) {
       svc.decisionFunction(p.x_dev, p.n_rows, p.n_cols, y_pred.data());
       EXPECT_TRUE(devArrMatchHost(exp.decision_function.data(),
                                   y_pred.data(),
                                   p.n_rows,
-                                  raft::CompareApprox<TypeParam>(1e-3f),
+                                  MLCommon::CompareApprox<TypeParam>(1e-3f),
                                   stream));
     }
   }
@@ -1310,8 +1318,8 @@ class SvrTest : public ::testing::Test {
     smo.SvrInit(y_dev.data(), n_rows, yc.data(), f.data());
 
     EXPECT_TRUE(
-      devArrMatchHost(yc_exp, yc.data(), n_train, raft::CompareApprox<math_t>(1.0e-9), stream));
-    EXPECT_TRUE(devArrMatchHost(f_exp, f.data(), n_train, raft::Compare<math_t>(), stream));
+      devArrMatchHost(yc_exp, yc.data(), n_train, MLCommon::CompareApprox<math_t>(1.0e-9), stream));
+    EXPECT_TRUE(devArrMatchHost(f_exp, f.data(), n_train, MLCommon::Compare<math_t>(), stream));
   }
 
   void TestSvrWorkingSet()
@@ -1328,7 +1336,7 @@ class SvrTest : public ::testing::Test {
     ws->Select(f.data(), alpha.data(), yc.data(), C_dev.data());
     int exp_idx[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
     ASSERT_TRUE(
-      devArrMatchHost(exp_idx, ws->GetIndices(), ws->GetSize(), raft::Compare<int>(), stream));
+      devArrMatchHost(exp_idx, ws->GetIndices(), ws->GetSize(), MLCommon::Compare<int>(), stream));
 
     delete ws;
 
@@ -1337,7 +1345,7 @@ class SvrTest : public ::testing::Test {
     ws->Select(f.data(), alpha.data(), yc.data(), C_dev.data());
     int exp_idx2[] = {6, 12, 5, 11, 3, 9, 8, 1, 7, 0};
     ASSERT_TRUE(
-      devArrMatchHost(exp_idx2, ws->GetIndices(), ws->GetSize(), raft::Compare<int>(), stream));
+      devArrMatchHost(exp_idx2, ws->GetIndices(), ws->GetSize(), MLCommon::Compare<int>(), stream));
     delete ws;
   }
 
@@ -1360,18 +1368,21 @@ class SvrTest : public ::testing::Test {
     ASSERT_EQ(model.n_support, 5);
     math_t dc_exp[] = {0.1, 0.3, -0.4, 0.9, -0.9};
     EXPECT_TRUE(devArrMatchHost(
-      dc_exp, model.dual_coefs, model.n_support, raft::CompareApprox<math_t>(1.0e-6), stream));
+      dc_exp, model.dual_coefs, model.n_support, MLCommon::CompareApprox<math_t>(1.0e-6), stream));
 
     math_t x_exp[] = {1, 2, 3, 5, 6};
     EXPECT_TRUE(devArrMatchHost(x_exp,
                                 model.x_support,
                                 model.n_support * n_cols,
-                                raft::CompareApprox<math_t>(1.0e-6),
+                                MLCommon::CompareApprox<math_t>(1.0e-6),
                                 stream));
 
     int idx_exp[] = {0, 1, 2, 4, 5};
-    EXPECT_TRUE(devArrMatchHost(
-      idx_exp, model.support_idx, model.n_support, raft::CompareApprox<math_t>(1.0e-6), stream));
+    EXPECT_TRUE(devArrMatchHost(idx_exp,
+                                model.support_idx,
+                                model.n_support,
+                                MLCommon::CompareApprox<math_t>(1.0e-6),
+                                stream));
   }
 
   void TestSvrFitPredict()
@@ -1481,7 +1492,7 @@ class SvrTest : public ::testing::Test {
         EXPECT_TRUE(devArrMatchHost(exp.decision_function.data(),
                                     preds.data(),
                                     p.n_rows,
-                                    raft::CompareApprox<math_t>(1.0e-5),
+                                    MLCommon::CompareApprox<math_t>(1.0e-5),
                                     stream));
       }
     }
diff --git a/cpp/test/sg/tsvd_test.cu b/cpp/test/sg/tsvd_test.cu
index e23df16784..1747c848b1 100644
--- a/cpp/test/sg/tsvd_test.cu
+++ b/cpp/test/sg/tsvd_test.cu
@@ -165,41 +165,41 @@ const std::vector<TsvdInputs<double>> inputsd2 = {{0.01, 4, 3, 1024, 128, 0.25f,
 typedef TsvdTest<float> TsvdTestLeftVecF;
 TEST_P(TsvdTestLeftVecF, Result)
 {
-  ASSERT_TRUE(raft::devArrMatch(components.data(),
-                                components_ref.data(),
-                                (params.n_col * params.n_col),
-                                raft::CompareApproxAbs<float>(params.tolerance),
-                                handle.get_stream()));
+  ASSERT_TRUE(MLCommon::devArrMatch(components.data(),
+                                    components_ref.data(),
+                                    (params.n_col * params.n_col),
+                                    MLCommon::CompareApproxAbs<float>(params.tolerance),
+                                    handle.get_stream()));
 }
 
 typedef TsvdTest<double> TsvdTestLeftVecD;
 TEST_P(TsvdTestLeftVecD, Result)
 {
-  ASSERT_TRUE(raft::devArrMatch(components.data(),
-                                components_ref.data(),
-                                (params.n_col * params.n_col),
-                                raft::CompareApproxAbs<double>(params.tolerance),
-                                handle.get_stream()));
+  ASSERT_TRUE(MLCommon::devArrMatch(components.data(),
+                                    components_ref.data(),
+                                    (params.n_col * params.n_col),
+                                    MLCommon::CompareApproxAbs<double>(params.tolerance),
+                                    handle.get_stream()));
 }
 
 typedef TsvdTest<float> TsvdTestDataVecF;
 TEST_P(TsvdTestDataVecF, Result)
 {
-  ASSERT_TRUE(raft::devArrMatch(data2.data(),
-                                data2_back.data(),
-                                (params.n_col2 * params.n_col2),
-                                raft::CompareApproxAbs<float>(params.tolerance),
-                                handle.get_stream()));
+  ASSERT_TRUE(MLCommon::devArrMatch(data2.data(),
+                                    data2_back.data(),
+                                    (params.n_col2 * params.n_col2),
+                                    MLCommon::CompareApproxAbs<float>(params.tolerance),
+                                    handle.get_stream()));
 }
 
 typedef TsvdTest<double> TsvdTestDataVecD;
 TEST_P(TsvdTestDataVecD, Result)
 {
-  ASSERT_TRUE(raft::devArrMatch(data2.data(),
-                                data2_back.data(),
-                                (params.n_col2 * params.n_col2),
-                                raft::CompareApproxAbs<double>(params.tolerance),
-                                handle.get_stream()));
+  ASSERT_TRUE(MLCommon::devArrMatch(data2.data(),
+                                    data2_back.data(),
+                                    (params.n_col2 * params.n_col2),
+                                    MLCommon::CompareApproxAbs<double>(params.tolerance),
+                                    handle.get_stream()));
 }
 
 INSTANTIATE_TEST_CASE_P(TsvdTests, TsvdTestLeftVecF, ::testing::ValuesIn(inputsf2));
diff --git a/cpp/test/sg/umap_parametrizable_test.cu b/cpp/test/sg/umap_parametrizable_test.cu
index 3cb34c6080..f852224396 100644
--- a/cpp/test/sg/umap_parametrizable_test.cu
+++ b/cpp/test/sg/umap_parametrizable_test.cu
@@ -352,8 +352,8 @@ class UMAPParametrizableTest : public ::testing::Test {
 
     ASSERT_TRUE(equal);
 #else
-    ASSERT_TRUE(
-      raft::devArrMatch(e1, e2, n_samples * umap_params.n_components, raft::Compare<float>{}));
+    ASSERT_TRUE(MLCommon::devArrMatch(
+      e1, e2, n_samples * umap_params.n_components, MLCommon::Compare<float>{}));
 #endif
   }