diff --git a/src/Microsoft.ML.CpuMath/CpuAligenedMathUtils.cs b/src/Microsoft.ML.CpuMath/CpuAligenedMathUtils.cs
index bcc92234d0..eacdd85213 100644
--- a/src/Microsoft.ML.CpuMath/CpuAligenedMathUtils.cs
+++ b/src/Microsoft.ML.CpuMath/CpuAligenedMathUtils.cs
@@ -85,7 +85,7 @@ public static void MatTimesSrc(ICpuFullMatrix mat, ICpuVector src, ICpuVector ds
             bool colMajor = typeof(TMatrix) == typeof(CpuAlignedMatrixCol);
             AssertCompatible(mat, src, dst);
             var m = A(mat);
-            CpuMathUtils.MatTimesSrc(colMajor, m.Items, A(src).Items, A(dst).Items, m.RunCnt);
+            CpuMathUtils.MatrixTimesSource(colMajor, m.Items, A(src).Items, A(dst).Items, m.RunCnt);
         }
 
         /// <summary>
@@ -100,7 +100,7 @@ public static void MatTranTimesSrc(ICpuFullMatrix mat, ICpuVector src, ICpuVecto
             bool colMajor = typeof(TMatrix) == typeof(CpuAlignedMatrixCol);
             AssertCompatible(mat, dst, src);
             var m = A(mat);
-            CpuMathUtils.MatTimesSrc(!colMajor, m.Items, A(src).Items, A(dst).Items, m.RunCnt);
+            CpuMathUtils.MatrixTimesSource(!colMajor, m.Items, A(src).Items, A(dst).Items, m.RunCnt);
         }
     }
 
diff --git a/src/Microsoft.ML.CpuMath/CpuMathUtils.netcoreapp.cs b/src/Microsoft.ML.CpuMath/CpuMathUtils.netcoreapp.cs
index 62e2adf6cc..e9d95ccc1d 100644
--- a/src/Microsoft.ML.CpuMath/CpuMathUtils.netcoreapp.cs
+++ b/src/Microsoft.ML.CpuMath/CpuMathUtils.netcoreapp.cs
@@ -24,497 +24,497 @@ public static partial class CpuMathUtils
         public static int GetVectorAlignment()
             => Avx.IsSupported ? Vector256Alignment : (Sse.IsSupported ? Vector128Alignment : FloatAlignment);
 
-        public static void MatTimesSrc(bool tran, AlignedArray mat, AlignedArray src, AlignedArray dst, int crun)
+        public static void MatrixTimesSource(bool transpose, AlignedArray matrix, AlignedArray source, AlignedArray destination, int stride)
         {
-            Contracts.Assert(mat.Size == dst.Size * src.Size);
-            Contracts.Assert(crun >= 0);
+            Contracts.Assert(matrix.Size == destination.Size * source.Size);
+            Contracts.Assert(stride >= 0);
 
             if (Avx.IsSupported)
             {
-                if (!tran)
+                if (!transpose)
                 {
-                    Contracts.Assert(crun <= dst.Size);
-                    AvxIntrinsics.MatMul(mat, src, dst, crun, src.Size);
+                    Contracts.Assert(stride <= destination.Size);
+                    AvxIntrinsics.MatMul(matrix, source, destination, stride, source.Size);
                 }
                 else
                 {
-                    Contracts.Assert(crun <= src.Size);
-                    AvxIntrinsics.MatMulTran(mat, src, dst, dst.Size, crun);
+                    Contracts.Assert(stride <= source.Size);
+                    AvxIntrinsics.MatMulTran(matrix, source, destination, destination.Size, stride);
                 }
             }
             else if (Sse.IsSupported)
             {
-                if (!tran)
+                if (!transpose)
                 {
-                    Contracts.Assert(crun <= dst.Size);
-                    SseIntrinsics.MatMul(mat, src, dst, crun, src.Size);
+                    Contracts.Assert(stride <= destination.Size);
+                    SseIntrinsics.MatMul(matrix, source, destination, stride, source.Size);
                 }
                 else
                 {
-                    Contracts.Assert(crun <= src.Size);
-                    SseIntrinsics.MatMulTran(mat, src, dst, dst.Size, crun);
+                    Contracts.Assert(stride <= source.Size);
+                    SseIntrinsics.MatMulTran(matrix, source, destination, destination.Size, stride);
                 }
             }
             else
             {
-                if (!tran)
+                if (!transpose)
                 {
-                    Contracts.Assert(crun <= dst.Size);
-                    for (int i = 0; i < crun; i++)
+                    Contracts.Assert(stride <= destination.Size);
+                    for (int i = 0; i < stride; i++)
                     {
                         float dotProduct = 0;
-                        for (int j = 0; j < src.Size; j++)
+                        for (int j = 0; j < source.Size; j++)
                         {
-                            dotProduct += mat[i * src.Size + j] * src[j];
+                            dotProduct += matrix[i * source.Size + j] * source[j];
                         }
 
-                        dst[i] = dotProduct;
+                        destination[i] = dotProduct;
                     }
                 }
                 else
                 {
-                    Contracts.Assert(crun <= src.Size);
-                    for (int i = 0; i < dst.Size; i++)
+                    Contracts.Assert(stride <= source.Size);
+                    for (int i = 0; i < destination.Size; i++)
                     {
                         float dotProduct = 0;
-                        for (int j = 0; j < crun; j++)
+                        for (int j = 0; j < stride; j++)
                         {
-                            dotProduct += mat[j * src.Size + i] * src[j];
+                            dotProduct += matrix[j * source.Size + i] * source[j];
                         }
 
-                        dst[i] = dotProduct;
+                        destination[i] = dotProduct;
                     }
                 }
             }
         }
 
-        public static void MatTimesSrc(AlignedArray mat, int[] rgposSrc, AlignedArray srcValues,
-            int posMin, int iposMin, int iposLim, AlignedArray dst, int crun)
+        public static void MatrixTimesSource(AlignedArray matrix, int[] rgposSrc, AlignedArray sourceValues,
+            int posMin, int iposMin, int iposLimit, AlignedArray destination, int stride)
         {
             Contracts.AssertValue(rgposSrc);
             Contracts.Assert(iposMin >= 0);
-            Contracts.Assert(iposMin <= iposLim);
-            Contracts.Assert(iposLim <= rgposSrc.Length);
-            Contracts.Assert(mat.Size == dst.Size * srcValues.Size);
+            Contracts.Assert(iposMin <= iposLimit);
+            Contracts.Assert(iposLimit <= rgposSrc.Length);
+            Contracts.Assert(matrix.Size == destination.Size * sourceValues.Size);
 
-            if (iposMin >= iposLim)
+            if (iposMin >= iposLimit)
             {
-                dst.ZeroItems();
+                destination.ZeroItems();
                 return;
             }
 
             Contracts.AssertNonEmpty(rgposSrc);
-            Contracts.Assert(crun >= 0);
+            Contracts.Assert(stride >= 0);
 
             if (Avx.IsSupported)
             {
-                Contracts.Assert(crun <= dst.Size);
-                AvxIntrinsics.MatMulP(mat, rgposSrc, srcValues, posMin, iposMin, iposLim, dst, crun, srcValues.Size);
+                Contracts.Assert(stride <= destination.Size);
+                AvxIntrinsics.MatMulP(matrix, rgposSrc, sourceValues, posMin, iposMin, iposLimit, destination, stride, sourceValues.Size);
             }
             else if (Sse.IsSupported)
             {
-                Contracts.Assert(crun <= dst.Size);
-                SseIntrinsics.MatMulP(mat, rgposSrc, srcValues, posMin, iposMin, iposLim, dst, crun, srcValues.Size);
+                Contracts.Assert(stride <= destination.Size);
+                SseIntrinsics.MatMulP(matrix, rgposSrc, sourceValues, posMin, iposMin, iposLimit, destination, stride, sourceValues.Size);
             }
             else
             {
-                Contracts.Assert(crun <= dst.Size);
-                for (int i = 0; i < crun; i++)
+                Contracts.Assert(stride <= destination.Size);
+                for (int i = 0; i < stride; i++)
                 {
                     float dotProduct = 0;
-                    for (int j = iposMin; j < iposLim; j++)
+                    for (int j = iposMin; j < iposLimit; j++)
                     {
                         int col = rgposSrc[j] - posMin;
-                        dotProduct += mat[i * srcValues.Size + col] * srcValues[col];
+                        dotProduct += matrix[i * sourceValues.Size + col] * sourceValues[col];
                     }
-                    dst[i] = dotProduct;
+                    destination[i] = dotProduct;
                 }
             }
         }
 
-        public static void Add(float a, Span<float> dst)
+        public static void Add(float value, Span<float> destination)
         {
-            Contracts.AssertNonEmpty(dst);
+            Contracts.AssertNonEmpty(destination);
 
             if (Avx.IsSupported)
             {
-                AvxIntrinsics.AddScalarU(a, dst);
+                AvxIntrinsics.AddScalarU(value, destination);
             }
             else if (Sse.IsSupported)
             {
-                SseIntrinsics.AddScalarU(a, dst);
+                SseIntrinsics.AddScalarU(value, destination);
             }
             else
             {
-                for (int i = 0; i < dst.Length; i++)
+                for (int i = 0; i < destination.Length; i++)
                 {
-                    dst[i] += a;
+                    destination[i] += value;
                 }
             }
         }
 
-        public static void Scale(float a, Span<float> dst)
+        public static void Scale(float value, Span<float> destination)
         {
-            Contracts.AssertNonEmpty(dst);
+            Contracts.AssertNonEmpty(destination);
 
             if (Avx.IsSupported)
             {
-                AvxIntrinsics.Scale(a, dst);
+                AvxIntrinsics.Scale(value, destination);
             }
             else if (Sse.IsSupported)
             {
-                SseIntrinsics.Scale(a, dst);
+                SseIntrinsics.Scale(value, destination);
             }
             else
             {
-                for (int i = 0; i < dst.Length; i++)
+                for (int i = 0; i < destination.Length; i++)
                 {
-                    dst[i] *= a;
+                    destination[i] *= value;
                 }
             }
         }
 
-        // dst = a * src
-        public static void Scale(float a, ReadOnlySpan<float> src, Span<float> dst, int count)
+        // destination = value * source
+        public static void Scale(float value, ReadOnlySpan<float> source, Span<float> destination, int count)
         {
-            Contracts.AssertNonEmpty(src);
-            Contracts.AssertNonEmpty(dst);
+            Contracts.AssertNonEmpty(source);
+            Contracts.AssertNonEmpty(destination);
             Contracts.Assert(count > 0);
-            Contracts.Assert(count <= src.Length);
-            Contracts.Assert(count <= dst.Length);
+            Contracts.Assert(count <= source.Length);
+            Contracts.Assert(count <= destination.Length);
 
             if (Avx.IsSupported)
             {
-                AvxIntrinsics.ScaleSrcU(a, src, dst, count);
+                AvxIntrinsics.ScaleSrcU(value, source, destination, count);
             }
             else if (Sse.IsSupported)
             {
-                SseIntrinsics.ScaleSrcU(a, src, dst, count);
+                SseIntrinsics.ScaleSrcU(value, source, destination, count);
             }
             else
             {
                 for (int i = 0; i < count; i++)
                 {
-                    dst[i] = a * src[i];
+                    destination[i] = value * source[i];
                 }
             }
         }
 
-        // dst[i] = a * (dst[i] + b)
-        public static void ScaleAdd(float a, float b, Span<float> dst)
+        // destination[i] = scale * (destination[i] + addend)
+        public static void ScaleAdd(float scale, float addend, Span<float> destination)
         {
-            Contracts.AssertNonEmpty(dst);
+            Contracts.AssertNonEmpty(destination);
 
             if (Avx.IsSupported)
             {
-                AvxIntrinsics.ScaleAddU(a, b, dst);
+                AvxIntrinsics.ScaleAddU(scale, addend, destination);
             }
             else if (Sse.IsSupported)
             {
-                SseIntrinsics.ScaleAddU(a, b, dst);
+                SseIntrinsics.ScaleAddU(scale, addend, destination);
             }
             else
             {
-                for (int i = 0; i < dst.Length; i++)
+                for (int i = 0; i < destination.Length; i++)
                 {
-                    dst[i] = a * (dst[i] + b);
+                    destination[i] = scale * (destination[i] + addend);
                 }
             }
         }
 
-        public static void AddScale(float a, ReadOnlySpan<float> src, Span<float> dst, int count)
+        public static void AddScale(float scale, ReadOnlySpan<float> source, Span<float> destination, int count)
         {
-            Contracts.AssertNonEmpty(src);
-            Contracts.AssertNonEmpty(dst);
+            Contracts.AssertNonEmpty(source);
+            Contracts.AssertNonEmpty(destination);
             Contracts.Assert(count > 0);
-            Contracts.Assert(count <= src.Length);
-            Contracts.Assert(count <= dst.Length);
+            Contracts.Assert(count <= source.Length);
+            Contracts.Assert(count <= destination.Length);
 
             if (Avx.IsSupported)
             {
-                AvxIntrinsics.AddScaleU(a, src, dst, count);
+                AvxIntrinsics.AddScaleU(scale, source, destination, count);
             }
             else if (Sse.IsSupported)
             {
-                SseIntrinsics.AddScaleU(a, src, dst, count);
+                SseIntrinsics.AddScaleU(scale, source, destination, count);
             }
             else
             {
                 for (int i = 0; i < count; i++)
                 {
-                    dst[i] += a * src[i];
+                    destination[i] += scale * source[i];
                 }
             }
         }
 
-        public static void AddScale(float a, ReadOnlySpan<float> src, ReadOnlySpan<int> indices, Span<float> dst, int count)
+        public static void AddScale(float scale, ReadOnlySpan<float> source, ReadOnlySpan<int> indices, Span<float> destination, int count)
         {
-            Contracts.AssertNonEmpty(src);
+            Contracts.AssertNonEmpty(source);
             Contracts.AssertNonEmpty(indices);
-            Contracts.AssertNonEmpty(dst);
+            Contracts.AssertNonEmpty(destination);
             Contracts.Assert(count > 0);
-            Contracts.Assert(count <= src.Length);
+            Contracts.Assert(count <= source.Length);
             Contracts.Assert(count <= indices.Length);
-            Contracts.Assert(count < dst.Length);
+            Contracts.Assert(count < destination.Length);
 
             if (Avx.IsSupported)
             {
-                AvxIntrinsics.AddScaleSU(a, src, indices, dst, count);
+                AvxIntrinsics.AddScaleSU(scale, source, indices, destination, count);
             }
             else if (Sse.IsSupported)
             {
-                SseIntrinsics.AddScaleSU(a, src, indices, dst, count);
+                SseIntrinsics.AddScaleSU(scale, source, indices, destination, count);
             }
             else
             {
                 for (int i = 0; i < count; i++)
                 {
                     int index = indices[i];
-                    dst[index] += a * src[i];
+                    destination[index] += scale * source[i];
                 }
             }
         }
 
-        public static void AddScaleCopy(float a, ReadOnlySpan<float> src, ReadOnlySpan<float> dst, Span<float> res, int count)
+        public static void AddScaleCopy(float scale, ReadOnlySpan<float> source, ReadOnlySpan<float> destination, Span<float> result, int count)
         {
-            Contracts.AssertNonEmpty(src);
-            Contracts.AssertNonEmpty(dst);
-            Contracts.AssertNonEmpty(res);
+            Contracts.AssertNonEmpty(source);
+            Contracts.AssertNonEmpty(destination);
+            Contracts.AssertNonEmpty(result);
             Contracts.Assert(count > 0);
-            Contracts.Assert(count <= src.Length);
-            Contracts.Assert(count <= dst.Length);
-            Contracts.Assert(count <= res.Length);
+            Contracts.Assert(count <= source.Length);
+            Contracts.Assert(count <= destination.Length);
+            Contracts.Assert(count <= result.Length);
 
             if (Avx.IsSupported)
             {
-                AvxIntrinsics.AddScaleCopyU(a, src, dst, res, count);
+                AvxIntrinsics.AddScaleCopyU(scale, source, destination, result, count);
             }
             else if (Sse.IsSupported)
             {
-                SseIntrinsics.AddScaleCopyU(a, src, dst, res, count);
+                SseIntrinsics.AddScaleCopyU(scale, source, destination, result, count);
             }
             else
             {
                 for (int i = 0; i < count; i++)
                 {
-                    res[i] = a * src[i] + dst[i];
+                    result[i] = scale * source[i] + destination[i];
                 }
             }
         }
 
-        public static void Add(ReadOnlySpan<float> src, Span<float> dst, int count)
+        public static void Add(ReadOnlySpan<float> source, Span<float> destination, int count)
         {
-            Contracts.AssertNonEmpty(src);
-            Contracts.AssertNonEmpty(dst);
+            Contracts.AssertNonEmpty(source);
+            Contracts.AssertNonEmpty(destination);
             Contracts.Assert(count > 0);
-            Contracts.Assert(count <= src.Length);
-            Contracts.Assert(count <= dst.Length);
+            Contracts.Assert(count <= source.Length);
+            Contracts.Assert(count <= destination.Length);
 
             if (Avx.IsSupported)
             {
-                AvxIntrinsics.AddU(src, dst, count);
+                AvxIntrinsics.AddU(source, destination, count);
             }
             else if (Sse.IsSupported)
             {
-                SseIntrinsics.AddU(src, dst, count);
+                SseIntrinsics.AddU(source, destination, count);
             }
             else
             {
                 for (int i = 0; i < count; i++)
                 {
-                    dst[i] += src[i];
+                    destination[i] += source[i];
                 }
             }
         }
 
-        public static void Add(ReadOnlySpan<float> src, ReadOnlySpan<int> indices, Span<float> dst, int count)
+        public static void Add(ReadOnlySpan<float> source, ReadOnlySpan<int> indices, Span<float> destination, int count)
         {
-            Contracts.AssertNonEmpty(src);
+            Contracts.AssertNonEmpty(source);
             Contracts.AssertNonEmpty(indices);
-            Contracts.AssertNonEmpty(dst);
+            Contracts.AssertNonEmpty(destination);
             Contracts.Assert(count > 0);
-            Contracts.Assert(count <= src.Length);
+            Contracts.Assert(count <= source.Length);
             Contracts.Assert(count <= indices.Length);
-            Contracts.Assert(count < dst.Length);
+            Contracts.Assert(count < destination.Length);
 
             if (Avx.IsSupported)
             {
-                AvxIntrinsics.AddSU(src, indices, dst, count);
+                AvxIntrinsics.AddSU(source, indices, destination, count);
             }
             else if (Sse.IsSupported)
             {
-                SseIntrinsics.AddSU(src, indices, dst, count);
+                SseIntrinsics.AddSU(source, indices, destination, count);
             }
             else
             {
                 for (int i = 0; i < count; i++)
                 {
                     int index = indices[i];
-                    dst[index] += src[i];
+                    destination[index] += source[i];
                 }
             }
         }
 
-        public static void MulElementWise(ReadOnlySpan<float> src1, ReadOnlySpan<float> src2, Span<float> dst, int count)
+        public static void MulElementWise(ReadOnlySpan<float> left, ReadOnlySpan<float> right, Span<float> destination, int count)
         {
-            Contracts.AssertNonEmpty(src1);
-            Contracts.AssertNonEmpty(src2);
-            Contracts.AssertNonEmpty(dst);
+            Contracts.AssertNonEmpty(left);
+            Contracts.AssertNonEmpty(right);
+            Contracts.AssertNonEmpty(destination);
             Contracts.Assert(count > 0);
-            Contracts.Assert(count <= src1.Length);
-            Contracts.Assert(count <= src2.Length);
-            Contracts.Assert(count <= dst.Length);
+            Contracts.Assert(count <= left.Length);
+            Contracts.Assert(count <= right.Length);
+            Contracts.Assert(count <= destination.Length);
 
             if (Avx.IsSupported)
             {
-                AvxIntrinsics.MulElementWiseU(src1, src2, dst, count);
+                AvxIntrinsics.MulElementWiseU(left, right, destination, count);
             }
             else if (Sse.IsSupported)
             {
-                SseIntrinsics.MulElementWiseU(src1, src2, dst, count);
+                SseIntrinsics.MulElementWiseU(left, right, destination, count);
             }
             else
             {
                 for (int i = 0; i < count; i++)
                 {
-                    dst[i] = src1[i] * src2[i];
+                    destination[i] = left[i] * right[i];
                 }
             }
         }
 
-        public static float Sum(ReadOnlySpan<float> src)
+        public static float Sum(ReadOnlySpan<float> source)
         {
-            Contracts.AssertNonEmpty(src);
+            Contracts.AssertNonEmpty(source);
 
             if (Avx.IsSupported)
             {
-                return AvxIntrinsics.Sum(src);
+                return AvxIntrinsics.Sum(source);
             }
             else if (Sse.IsSupported)
             {
-                return SseIntrinsics.Sum(src);
+                return SseIntrinsics.Sum(source);
             }
             else
             {
                 float sum = 0;
-                for (int i = 0; i < src.Length; i++)
+                for (int i = 0; i < source.Length; i++)
                 {
-                    sum += src[i];
+                    sum += source[i];
                 }
                 return sum;
             }
         }
 
-        public static float SumSq(ReadOnlySpan<float> src)
+        public static float SumSq(ReadOnlySpan<float> source)
         {
-            Contracts.AssertNonEmpty(src);
+            Contracts.AssertNonEmpty(source);
 
             if (Avx.IsSupported)
             {
-                return AvxIntrinsics.SumSqU(src);
+                return AvxIntrinsics.SumSqU(source);
             }
             else if (Sse.IsSupported)
             {
-                return SseIntrinsics.SumSqU(src);
+                return SseIntrinsics.SumSqU(source);
             }
             else
             {
                 float result = 0;
-                for (int i = 0; i < src.Length; i++)
+                for (int i = 0; i < source.Length; i++)
                 {
-                    result += src[i] * src[i];
+                    result += source[i] * source[i];
                 }
                 return result;
             }
         }
 
-        public static float SumSq(float mean, ReadOnlySpan<float> src)
+        public static float SumSq(float mean, ReadOnlySpan<float> source)
         {
-            Contracts.AssertNonEmpty(src);
+            Contracts.AssertNonEmpty(source);
 
             if (Avx.IsSupported)
             {
-                return (mean == 0) ? AvxIntrinsics.SumSqU(src) : AvxIntrinsics.SumSqDiffU(mean, src);
+                return (mean == 0) ? AvxIntrinsics.SumSqU(source) : AvxIntrinsics.SumSqDiffU(mean, source);
             }
             else if (Sse.IsSupported)
             {
-                return (mean == 0) ? SseIntrinsics.SumSqU(src) : SseIntrinsics.SumSqDiffU(mean, src);
+                return (mean == 0) ? SseIntrinsics.SumSqU(source) : SseIntrinsics.SumSqDiffU(mean, source);
             }
             else
             {
                 float result = 0;
-                for (int i = 0; i < src.Length; i++)
+                for (int i = 0; i < source.Length; i++)
                 {
-                    result += (src[i] - mean) * (src[i] - mean);
+                    result += (source[i] - mean) * (source[i] - mean);
                 }
                 return result;
             }
         }
 
-        public static float SumAbs(ReadOnlySpan<float> src)
+        public static float SumAbs(ReadOnlySpan<float> source)
         {
-            Contracts.AssertNonEmpty(src);
+            Contracts.AssertNonEmpty(source);
 
             if (Avx.IsSupported)
             {
-                return AvxIntrinsics.SumAbsU(src);
+                return AvxIntrinsics.SumAbsU(source);
             }
             else if (Sse.IsSupported)
             {
-                return SseIntrinsics.SumAbsU(src);
+                return SseIntrinsics.SumAbsU(source);
             }
             else
             {
                 float sum = 0;
-                for (int i = 0; i < src.Length; i++)
+                for (int i = 0; i < source.Length; i++)
                 {
-                    sum += Math.Abs(src[i]);
+                    sum += Math.Abs(source[i]);
                 }
                 return sum;
             }
         }
 
-        public static float SumAbs(float mean, ReadOnlySpan<float> src)
+        public static float SumAbs(float mean, ReadOnlySpan<float> source)
         {
-            Contracts.AssertNonEmpty(src);
+            Contracts.AssertNonEmpty(source);
 
             if (Avx.IsSupported)
             {
-                return (mean == 0) ? AvxIntrinsics.SumAbsU(src) : AvxIntrinsics.SumAbsDiffU(mean, src);
+                return (mean == 0) ? AvxIntrinsics.SumAbsU(source) : AvxIntrinsics.SumAbsDiffU(mean, source);
             }
             else if (Sse.IsSupported)
             {
-                return (mean == 0) ? SseIntrinsics.SumAbsU(src) : SseIntrinsics.SumAbsDiffU(mean, src);
+                return (mean == 0) ? SseIntrinsics.SumAbsU(source) : SseIntrinsics.SumAbsDiffU(mean, source);
             }
             else
             {
                 float sum = 0;
-                for (int i = 0; i < src.Length; i++)
+                for (int i = 0; i < source.Length; i++)
                 {
-                    sum += Math.Abs(src[i] - mean);
+                    sum += Math.Abs(source[i] - mean);
                 }
                 return sum;
             }
         }
 
-        public static float MaxAbs(ReadOnlySpan<float> src)
+        public static float MaxAbs(ReadOnlySpan<float> source)
         {
-            Contracts.AssertNonEmpty(src);
+            Contracts.AssertNonEmpty(source);
 
             if (Avx.IsSupported)
             {
-                return AvxIntrinsics.MaxAbsU(src);
+                return AvxIntrinsics.MaxAbsU(source);
             }
             else if (Sse.IsSupported)
             {
-                return SseIntrinsics.MaxAbsU(src);
+                return SseIntrinsics.MaxAbsU(source);
             }
             else
             {
                 float max = 0;
-                for (int i = 0; i < src.Length; i++)
+                for (int i = 0; i < source.Length; i++)
                 {
-                    float abs = Math.Abs(src[i]);
+                    float abs = Math.Abs(source[i]);
                     if (abs > max)
                     {
                         max = abs;
@@ -524,24 +524,24 @@ public static float MaxAbs(ReadOnlySpan<float> src)
             }
         }
 
-        public static float MaxAbsDiff(float mean, ReadOnlySpan<float> src)
+        public static float MaxAbsDiff(float mean, ReadOnlySpan<float> source)
         {
-            Contracts.AssertNonEmpty(src);
+            Contracts.AssertNonEmpty(source);
 
             if (Avx.IsSupported)
             {
-                return AvxIntrinsics.MaxAbsDiffU(mean, src);
+                return AvxIntrinsics.MaxAbsDiffU(mean, source);
             }
             else if (Sse.IsSupported)
             {
-                return SseIntrinsics.MaxAbsDiffU(mean, src);
+                return SseIntrinsics.MaxAbsDiffU(mean, source);
             }
             else
             {
                 float max = 0;
-                for (int i = 0; i < src.Length; i++)
+                for (int i = 0; i < source.Length; i++)
                 {
-                    float abs = Math.Abs(src[i] - mean);
+                    float abs = Math.Abs(source[i] - mean);
                     if (abs > max)
                     {
                         max = abs;
@@ -551,50 +551,50 @@ public static float MaxAbsDiff(float mean, ReadOnlySpan<float> src)
             }
         }
 
-        public static float DotProductDense(ReadOnlySpan<float> a, ReadOnlySpan<float> b, int count)
+        public static float DotProductDense(ReadOnlySpan<float> left, ReadOnlySpan<float> right, int count)
         {
-            Contracts.AssertNonEmpty(a);
-            Contracts.AssertNonEmpty(b);
+            Contracts.AssertNonEmpty(left);
+            Contracts.AssertNonEmpty(right);
             Contracts.Assert(count > 0);
-            Contracts.Assert(a.Length >= count);
-            Contracts.Assert(b.Length >= count);
+            Contracts.Assert(left.Length >= count);
+            Contracts.Assert(right.Length >= count);
 
             if (Avx.IsSupported)
             {
-                return AvxIntrinsics.DotU(a, b, count);
+                return AvxIntrinsics.DotU(left, right, count);
             }
             else if (Sse.IsSupported)
             {
-                return SseIntrinsics.DotU(a, b, count);
+                return SseIntrinsics.DotU(left, right, count);
             }
             else
             {
                 float result = 0;
                 for (int i = 0; i < count; i++)
                 {
-                    result += a[i] * b[i];
+                    result += left[i] * right[i];
                 }
                 return result;
             }
         }
 
-        public static float DotProductSparse(ReadOnlySpan<float> a, ReadOnlySpan<float> b, ReadOnlySpan<int> indices, int count)
+        public static float DotProductSparse(ReadOnlySpan<float> left, ReadOnlySpan<float> right, ReadOnlySpan<int> indices, int count)
         {
-            Contracts.AssertNonEmpty(a);
-            Contracts.AssertNonEmpty(b);
+            Contracts.AssertNonEmpty(left);
+            Contracts.AssertNonEmpty(right);
             Contracts.AssertNonEmpty(indices);
             Contracts.Assert(count > 0);
-            Contracts.Assert(count < a.Length);
-            Contracts.Assert(count <= b.Length);
+            Contracts.Assert(count < left.Length);
+            Contracts.Assert(count <= right.Length);
             Contracts.Assert(count <= indices.Length);
 
             if (Avx.IsSupported)
             {
-                return AvxIntrinsics.DotSU(a, b, indices, count);
+                return AvxIntrinsics.DotSU(left, right, indices, count);
             }
             else if (Sse.IsSupported)
             {
-                return SseIntrinsics.DotSU(a, b, indices, count);
+                return SseIntrinsics.DotSU(left, right, indices, count);
             }
             else
             {
@@ -602,58 +602,58 @@ public static float DotProductSparse(ReadOnlySpan<float> a, ReadOnlySpan<float>
                 for (int i = 0; i < count; i++)
                 {
                     int index = indices[i];
-                    result += a[index] * b[i];
+                    result += left[index] * right[i];
                 }
                 return result;
             }
         }
 
-        public static float L2DistSquared(ReadOnlySpan<float> a, ReadOnlySpan<float> b, int count)
+        public static float L2DistSquared(ReadOnlySpan<float> left, ReadOnlySpan<float> right, int count)
         {
-            Contracts.AssertNonEmpty(a);
-            Contracts.AssertNonEmpty(b);
+            Contracts.AssertNonEmpty(left);
+            Contracts.AssertNonEmpty(right);
             Contracts.Assert(count > 0);
-            Contracts.Assert(count <= a.Length);
-            Contracts.Assert(count <= b.Length);
+            Contracts.Assert(count <= left.Length);
+            Contracts.Assert(count <= right.Length);
 
             if (Avx.IsSupported)
             {
-                return AvxIntrinsics.Dist2(a, b, count);
+                return AvxIntrinsics.Dist2(left, right, count);
             }
             else if (Sse.IsSupported)
             {
-                return SseIntrinsics.Dist2(a, b, count);
+                return SseIntrinsics.Dist2(left, right, count);
             }
             else
             {
                 float norm = 0;
                 for (int i = 0; i < count; i++)
                 {
-                    float distance = a[i] - b[i];
+                    float distance = left[i] - right[i];
                     norm += distance * distance;
                 }
                 return norm;
             }
         }
 
-        public static void ZeroMatrixItems(AlignedArray dst, int ccol, int cfltRow, int[] indices)
+        public static void ZeroMatrixItems(AlignedArray destination, int ccol, int cfltRow, int[] indices)
         {
             Contracts.Assert(ccol > 0);
             Contracts.Assert(ccol <= cfltRow);
 
             if (ccol == cfltRow)
             {
-                ZeroItemsU(dst, dst.Size, indices, indices.Length);
+                ZeroItemsU(destination, destination.Size, indices, indices.Length);
             }
             else
             {
-                ZeroMatrixItemsCore(dst, dst.Size, ccol, cfltRow, indices, indices.Length);
+                ZeroMatrixItemsCore(destination, destination.Size, ccol, cfltRow, indices, indices.Length);
             }
         }
 
-        private static unsafe void ZeroItemsU(AlignedArray dst, int c, int[] indices, int cindices)
+        private static unsafe void ZeroItemsU(AlignedArray destination, int c, int[] indices, int cindices)
         {
-            fixed (float* pdst = &dst.Items[0])
+            fixed (float* pdst = &destination.Items[0])
             fixed (int* pidx = &indices[0])
             {
                 for (int i = 0; i < cindices; ++i)
@@ -666,9 +666,9 @@ private static unsafe void ZeroItemsU(AlignedArray dst, int c, int[] indices, in
             }
         }
 
-        private static unsafe void ZeroMatrixItemsCore(AlignedArray dst, int c, int ccol, int cfltRow, int[] indices, int cindices)
+        private static unsafe void ZeroMatrixItemsCore(AlignedArray destination, int c, int ccol, int cfltRow, int[] indices, int cindices)
         {
-            fixed (float* pdst = &dst.Items[0])
+            fixed (float* pdst = &destination.Items[0])
             fixed (int* pidx = &indices[0])
             {
                 int ivLogMin = 0;
@@ -701,61 +701,61 @@ private static unsafe void ZeroMatrixItemsCore(AlignedArray dst, int c, int ccol
             }
         }
 
-        public static void SdcaL1UpdateDense(float primalUpdate, int count, ReadOnlySpan<float> src, float threshold, Span<float> v, Span<float> w)
+        public static void SdcaL1UpdateDense(float primalUpdate, int count, ReadOnlySpan<float> source, float threshold, Span<float> v, Span<float> w)
         {
-            Contracts.AssertNonEmpty(src);
+            Contracts.AssertNonEmpty(source);
             Contracts.AssertNonEmpty(v);
             Contracts.AssertNonEmpty(w);
             Contracts.Assert(count > 0);
-            Contracts.Assert(count <= src.Length);
+            Contracts.Assert(count <= source.Length);
             Contracts.Assert(count <= v.Length);
             Contracts.Assert(count <= w.Length);
 
             if (Avx.IsSupported)
             {
-                AvxIntrinsics.SdcaL1UpdateU(primalUpdate, count, src, threshold, v, w);
+                AvxIntrinsics.SdcaL1UpdateU(primalUpdate, count, source, threshold, v, w);
             }
             else if (Sse.IsSupported)
             {
-                SseIntrinsics.SdcaL1UpdateU(primalUpdate, count, src, threshold, v, w);
+                SseIntrinsics.SdcaL1UpdateU(primalUpdate, count, source, threshold, v, w);
             }
             else
             {
                 for (int i = 0; i < count; i++)
                 {
-                    v[i] += src[i] * primalUpdate;
+                    v[i] += source[i] * primalUpdate;
                     float value = v[i];
                     w[i] = Math.Abs(value) > threshold ? (value > 0 ? value - threshold : value + threshold) : 0;
                 }
             }
         }
 
-        public static void SdcaL1UpdateSparse(float primalUpdate, int count, ReadOnlySpan<float> src, ReadOnlySpan<int> indices, float threshold, Span<float> v, Span<float> w)
+        public static void SdcaL1UpdateSparse(float primalUpdate, int count, ReadOnlySpan<float> source, ReadOnlySpan<int> indices, float threshold, Span<float> v, Span<float> w)
         {
-            Contracts.AssertNonEmpty(src);
+            Contracts.AssertNonEmpty(source);
             Contracts.AssertNonEmpty(indices);
             Contracts.AssertNonEmpty(v);
             Contracts.AssertNonEmpty(w);
             Contracts.Assert(count > 0);
-            Contracts.Assert(count <= src.Length);
+            Contracts.Assert(count <= source.Length);
             Contracts.Assert(count <= indices.Length);
             Contracts.Assert(count <= v.Length);
             Contracts.Assert(count <= w.Length);
 
             if (Avx.IsSupported)
             {
-                AvxIntrinsics.SdcaL1UpdateSU(primalUpdate, count, src, indices, threshold, v, w);
+                AvxIntrinsics.SdcaL1UpdateSU(primalUpdate, count, source, indices, threshold, v, w);
             }
             else if (Sse.IsSupported)
             {
-                SseIntrinsics.SdcaL1UpdateSU(primalUpdate, count, src, indices, threshold, v, w);
+                SseIntrinsics.SdcaL1UpdateSU(primalUpdate, count, source, indices, threshold, v, w);
             }
             else
             {
                 for (int i = 0; i < count; i++)
                 {
                     int index = indices[i];
-                    v[index] += src[i] * primalUpdate;
+                    v[index] += source[i] * primalUpdate;
                     float value = v[index];
                     w[index] = Math.Abs(value) > threshold ? (value > 0 ? value - threshold : value + threshold) : 0;
                 }
diff --git a/src/Microsoft.ML.CpuMath/CpuMathUtils.netstandard.cs b/src/Microsoft.ML.CpuMath/CpuMathUtils.netstandard.cs
index d3fbaea2dc..bc9569d390 100644
--- a/src/Microsoft.ML.CpuMath/CpuMathUtils.netstandard.cs
+++ b/src/Microsoft.ML.CpuMath/CpuMathUtils.netstandard.cs
@@ -16,57 +16,57 @@ public static partial class CpuMathUtils
         public static int GetVectorAlignment()
             => Vector128Alignment;
 
-        public static void MatTimesSrc(bool tran, AlignedArray mat, AlignedArray src, AlignedArray dst, int crun) => SseUtils.MatTimesSrc(tran, mat, src, dst, crun);
+        public static void MatrixTimesSource(bool transpose, AlignedArray matrix, AlignedArray source, AlignedArray destination, int stride) => SseUtils.MatTimesSrc(transpose, matrix, source, destination, stride);
 
-        public static void MatTimesSrc(AlignedArray mat, int[] rgposSrc, AlignedArray srcValues,
-            int posMin, int iposMin, int iposLim, AlignedArray dst, int crun) => SseUtils.MatTimesSrc(mat, rgposSrc, srcValues, posMin, iposMin, iposLim, dst, crun);
+        public static void MatrixTimesSource(AlignedArray matrix, int[] rgposSrc, AlignedArray sourceValues,
+            int posMin, int iposMin, int iposLimit, AlignedArray destination, int stride) => SseUtils.MatTimesSrc(matrix, rgposSrc, sourceValues, posMin, iposMin, iposLimit, destination, stride);
 
-        public static void Add(float a, Span<float> dst) => SseUtils.Add(a, dst);
+        public static void Add(float value, Span<float> destination) => SseUtils.Add(value, destination);
 
-        public static void Scale(float a, Span<float> dst) => SseUtils.Scale(a, dst);
+        public static void Scale(float value, Span<float> destination) => SseUtils.Scale(value, destination);
 
-        public static void Scale(float a, ReadOnlySpan<float> src, Span<float> dst, int count) => SseUtils.Scale(a, src, dst, count);
+        public static void Scale(float value, ReadOnlySpan<float> source, Span<float> destination, int count) => SseUtils.Scale(value, source, destination, count);
 
-        public static void ScaleAdd(float a, float b, Span<float> dst) => SseUtils.ScaleAdd(a, b, dst);
+        public static void ScaleAdd(float value, float addend, Span<float> destination) => SseUtils.ScaleAdd(value, addend, destination);
 
-        public static void AddScale(float a, ReadOnlySpan<float> src, Span<float> dst, int count) => SseUtils.AddScale(a, src, dst, count);
+        public static void AddScale(float value, ReadOnlySpan<float> source, Span<float> destination, int count) => SseUtils.AddScale(value, source, destination, count);
 
-        public static void AddScale(float a, ReadOnlySpan<float> src, ReadOnlySpan<int> indices, Span<float> dst, int count) => SseUtils.AddScale(a, src, indices, dst, count);
+        public static void AddScale(float value, ReadOnlySpan<float> source, ReadOnlySpan<int> indices, Span<float> destination, int count) => SseUtils.AddScale(value, source, indices, destination, count);
 
-        public static void AddScaleCopy(float a, ReadOnlySpan<float> src, ReadOnlySpan<float> dst, Span<float> res, int count) => SseUtils.AddScaleCopy(a, src, dst, res, count);
+        public static void AddScaleCopy(float value, ReadOnlySpan<float> source, ReadOnlySpan<float> destination, Span<float> res, int count) => SseUtils.AddScaleCopy(value, source, destination, res, count);
 
-        public static void Add(ReadOnlySpan<float> src, Span<float> dst, int count) => SseUtils.Add(src, dst, count);
+        public static void Add(ReadOnlySpan<float> source, Span<float> destination, int count) => SseUtils.Add(source, destination, count);
 
-        public static void Add(ReadOnlySpan<float> src, ReadOnlySpan<int> indices, Span<float> dst, int count) => SseUtils.Add(src, indices, dst, count);
+        public static void Add(ReadOnlySpan<float> source, ReadOnlySpan<int> indices, Span<float> destination, int count) => SseUtils.Add(source, indices, destination, count);
 
-        public static void MulElementWise(ReadOnlySpan<float> src1, ReadOnlySpan<float> src2, Span<float> dst, int count) => SseUtils.MulElementWise(src1, src2, dst, count);
+        public static void MulElementWise(ReadOnlySpan<float> left, ReadOnlySpan<float> right, Span<float> destination, int count) => SseUtils.MulElementWise(left, right, destination, count);
 
-        public static float Sum(ReadOnlySpan<float> src) => SseUtils.Sum(src);
+        public static float Sum(ReadOnlySpan<float> source) => SseUtils.Sum(source);
 
-        public static float SumSq(ReadOnlySpan<float> src) => SseUtils.SumSq(src);
+        public static float SumSq(ReadOnlySpan<float> source) => SseUtils.SumSq(source);
 
-        public static float SumSq(float mean, ReadOnlySpan<float> src) => SseUtils.SumSq(mean, src);
+        public static float SumSq(float mean, ReadOnlySpan<float> source) => SseUtils.SumSq(mean, source);
 
-        public static float SumAbs(ReadOnlySpan<float> src) => SseUtils.SumAbs(src);
+        public static float SumAbs(ReadOnlySpan<float> source) => SseUtils.SumAbs(source);
 
-        public static float SumAbs(float mean, ReadOnlySpan<float> src) => SseUtils.SumAbs(mean, src);
+        public static float SumAbs(float mean, ReadOnlySpan<float> source) => SseUtils.SumAbs(mean, source);
 
-        public static float MaxAbs(ReadOnlySpan<float> src) => SseUtils.MaxAbs(src);
+        public static float MaxAbs(ReadOnlySpan<float> source) => SseUtils.MaxAbs(source);
 
-        public static float MaxAbsDiff(float mean, ReadOnlySpan<float> src) => SseUtils.MaxAbsDiff(mean, src);
+        public static float MaxAbsDiff(float mean, ReadOnlySpan<float> source) => SseUtils.MaxAbsDiff(mean, source);
 
-        public static float DotProductDense(ReadOnlySpan<float> a, ReadOnlySpan<float> b, int count) => SseUtils.DotProductDense(a, b, count);
+        public static float DotProductDense(ReadOnlySpan<float> left, ReadOnlySpan<float> right, int count) => SseUtils.DotProductDense(left, right, count);
 
-        public static float DotProductSparse(ReadOnlySpan<float> a, ReadOnlySpan<float> b, ReadOnlySpan<int> indices, int count) => SseUtils.DotProductSparse(a, b, indices, count);
+        public static float DotProductSparse(ReadOnlySpan<float> left, ReadOnlySpan<float> right, ReadOnlySpan<int> indices, int count) => SseUtils.DotProductSparse(left, right, indices, count);
 
-        public static float L2DistSquared(ReadOnlySpan<float> a, ReadOnlySpan<float> b, int count) => SseUtils.L2DistSquared(a, b, count);
+        public static float L2DistSquared(ReadOnlySpan<float> left, ReadOnlySpan<float> right, int count) => SseUtils.L2DistSquared(left, right, count);
 
-        public static void ZeroMatrixItems(AlignedArray dst, int ccol, int cfltRow, int[] indices) => SseUtils.ZeroMatrixItems(dst, ccol, cfltRow, indices);
+        public static void ZeroMatrixItems(AlignedArray destination, int ccol, int cfltRow, int[] indices) => SseUtils.ZeroMatrixItems(destination, ccol, cfltRow, indices);
 
-        public static void SdcaL1UpdateDense(float primalUpdate, int count, ReadOnlySpan<float> src, float threshold, Span<float> v, Span<float> w)
-            => SseUtils.SdcaL1UpdateDense(primalUpdate, count, src, threshold, v, w);
+        public static void SdcaL1UpdateDense(float primalUpdate, int count, ReadOnlySpan<float> source, float threshold, Span<float> v, Span<float> w)
+            => SseUtils.SdcaL1UpdateDense(primalUpdate, count, source, threshold, v, w);
 
-        public static void SdcaL1UpdateSparse(float primalUpdate, int count, ReadOnlySpan<float> src, ReadOnlySpan<int> indices, float threshold, Span<float> v, Span<float> w)
-            => SseUtils.SdcaL1UpdateSparse(primalUpdate, count, src, indices, threshold, v, w);
+        public static void SdcaL1UpdateSparse(float primalUpdate, int count, ReadOnlySpan<float> source, ReadOnlySpan<int> indices, float threshold, Span<float> v, Span<float> w)
+            => SseUtils.SdcaL1UpdateSparse(primalUpdate, count, source, indices, threshold, v, w);
     }
 }
diff --git a/src/Microsoft.ML.CpuMath/Sse.cs b/src/Microsoft.ML.CpuMath/Sse.cs
index 2df08e805e..3ff59f2840 100644
--- a/src/Microsoft.ML.CpuMath/Sse.cs
+++ b/src/Microsoft.ML.CpuMath/Sse.cs
@@ -401,10 +401,10 @@ public static void SdcaL1UpdateDense(float primalUpdate, int count, ReadOnlySpan
             }
         }
 
-        public static void SdcaL1UpdateSparse(float primalUpdate, int count, ReadOnlySpan<float> src, ReadOnlySpan<int> indices, float threshold, Span<float> v, Span<float> w)
+        public static void SdcaL1UpdateSparse(float primalUpdate, int count, ReadOnlySpan<float> source, ReadOnlySpan<int> indices, float threshold, Span<float> v, Span<float> w)
         {
-            Contracts.AssertNonEmpty(src);
-            Contracts.Assert(count <= src.Length);
+            Contracts.AssertNonEmpty(source);
+            Contracts.Assert(count <= source.Length);
             Contracts.AssertNonEmpty(indices);
             Contracts.Assert(count <= indices.Length);
             Contracts.AssertNonEmpty(v);
@@ -415,7 +415,7 @@ public static void SdcaL1UpdateSparse(float primalUpdate, int count, ReadOnlySpa
 
             unsafe
             {
-                fixed (float* psrc = &MemoryMarshal.GetReference(src))
+                fixed (float* psrc = &MemoryMarshal.GetReference(source))
                 fixed (int* pi = &MemoryMarshal.GetReference(indices))
                 fixed (float* pd1 = &MemoryMarshal.GetReference(v))
                 fixed (float* pd2 = &MemoryMarshal.GetReference(w))
diff --git a/src/Microsoft.ML.Transforms/RffTransform.cs b/src/Microsoft.ML.Transforms/RffTransform.cs
index 8b86243453..30c311ca68 100644
--- a/src/Microsoft.ML.Transforms/RffTransform.cs
+++ b/src/Microsoft.ML.Transforms/RffTransform.cs
@@ -563,6 +563,7 @@ private ValueGetter<VBuffer<float>> GetterFromVectorType(IRow input, int iinfo)
                         getSrc(ref src);
                         TransformFeatures(ref src, ref dst, _parent._transformInfos[iinfo], featuresAligned, productAligned);
                     };
+
             }
 
             private ValueGetter<VBuffer<float>> GetterFromFloatType(IRow input, int iinfo)
@@ -607,7 +608,7 @@ private void TransformFeatures(ref VBuffer<float> src, ref VBuffer<float> dst, T
                 if (src.IsDense)
                 {
                     featuresAligned.CopyFrom(src.Values, 0, src.Length);
-                    CpuMathUtils.MatTimesSrc(false, transformInfo.RndFourierVectors, featuresAligned, productAligned,
+                    CpuMathUtils.MatrixTimesSource(false, transformInfo.RndFourierVectors, featuresAligned, productAligned,
                         transformInfo.NewDim);
                 }
                 else
@@ -615,7 +616,7 @@ private void TransformFeatures(ref VBuffer<float> src, ref VBuffer<float> dst, T
                     // This overload of MatTimesSrc ignores the values in slots that are not in src.Indices, so there is
                     // no need to zero them out.
                     featuresAligned.CopyFrom(src.Indices, src.Values, 0, 0, src.Count, zeroItems: false);
-                    CpuMathUtils.MatTimesSrc(transformInfo.RndFourierVectors, src.Indices, featuresAligned, 0, 0,
+                    CpuMathUtils.MatrixTimesSource(transformInfo.RndFourierVectors, src.Indices, featuresAligned, 0, 0,
                         src.Count, productAligned, transformInfo.NewDim);
                 }
 
diff --git a/test/Microsoft.ML.CpuMath.UnitTests.netcoreapp/UnitTests.cs b/test/Microsoft.ML.CpuMath.UnitTests.netcoreapp/UnitTests.cs
index 98467ab384..1d2b53bb79 100644
--- a/test/Microsoft.ML.CpuMath.UnitTests.netcoreapp/UnitTests.cs
+++ b/test/Microsoft.ML.CpuMath.UnitTests.netcoreapp/UnitTests.cs
@@ -90,7 +90,7 @@ public void MatMulTest(int matTest, int srcTest, int dstTest, float[] expected)
             AlignedArray src = _testSrcVectors[srcTest];
             AlignedArray dst = _testDstVectors[dstTest];
 
-            CpuMathUtils.MatTimesSrc(false, mat, src, dst, dst.Size);
+            CpuMathUtils.MatrixTimesSource(false, mat, src, dst, dst.Size);
             float[] actual = new float[dst.Size];
             dst.CopyTo(actual, 0, dst.Size);
             Assert.Equal(expected, actual, _matMulComparer);
@@ -106,7 +106,7 @@ public void MatMulTranTest(int matTest, int srcTest, int dstTest, float[] expect
             AlignedArray src = _testSrcVectors[srcTest];
             AlignedArray dst = _testDstVectors[dstTest];
 
-            CpuMathUtils.MatTimesSrc(true, mat, src, dst, src.Size);
+            CpuMathUtils.MatrixTimesSource(true, mat, src, dst, src.Size);
             float[] actual = new float[dst.Size];
             dst.CopyTo(actual, 0, dst.Size);
             Assert.Equal(expected, actual, _matMulComparer);
@@ -123,7 +123,7 @@ public void MatTimesSrcSparseTest(int matTest, int srcTest, int dstTest, float[]
             AlignedArray dst = _testDstVectors[dstTest];
             int[] idx = _testIndexArray;
 
-            CpuMathUtils.MatTimesSrc(mat, idx, src, 0, 0, (srcTest == 0) ? 4 : 9, dst, dst.Size);
+            CpuMathUtils.MatrixTimesSource(mat, idx, src, 0, 0, (srcTest == 0) ? 4 : 9, dst, dst.Size);
             float[] actual = new float[dst.Size];
             dst.CopyTo(actual, 0, dst.Size);
             Assert.Equal(expected, actual, _matMulComparer);