diff --git a/test/Microsoft.ML.CpuMath.PerformanceTests/AvxPerformanceTests.cs b/test/Microsoft.ML.CpuMath.PerformanceTests/AvxPerformanceTests.cs
index b4b1cf65fd..8e691b0847 100644
--- a/test/Microsoft.ML.CpuMath.PerformanceTests/AvxPerformanceTests.cs
+++ b/test/Microsoft.ML.CpuMath.PerformanceTests/AvxPerformanceTests.cs
@@ -13,91 +13,91 @@ public class AvxPerformanceTests : PerformanceTests
     {
         [Benchmark]
         public void AddScalarU()
-            => AvxIntrinsics.AddScalarU(DEFAULT_SCALE, new Span<float>(dst, 0, LEN));
+            => AvxIntrinsics.AddScalarU(DefaultScale, new Span<float>(dst, 0, Length));
 
         [Benchmark]
         public void ScaleU()
-            => AvxIntrinsics.ScaleU(DEFAULT_SCALE, new Span<float>(dst, 0, LEN));
+            => AvxIntrinsics.ScaleU(DefaultScale, new Span<float>(dst, 0, Length));
 
         [Benchmark]
         public void ScaleSrcU()
-            => AvxIntrinsics.ScaleSrcU(DEFAULT_SCALE, new Span<float>(src, 0, LEN), new Span<float>(dst, 0, LEN));
+            => AvxIntrinsics.ScaleSrcU(DefaultScale, new Span<float>(src, 0, Length), new Span<float>(dst, 0, Length));
 
         [Benchmark]
         public void ScaleAddU()
-            => AvxIntrinsics.ScaleAddU(DEFAULT_SCALE, DEFAULT_SCALE, new Span<float>(dst, 0, LEN));
+            => AvxIntrinsics.ScaleAddU(DefaultScale, DefaultScale, new Span<float>(dst, 0, Length));
 
         [Benchmark]
         public void AddScaleU()
-            => AvxIntrinsics.AddScaleU(DEFAULT_SCALE, new Span<float>(src, 0, LEN), new Span<float>(dst, 0, LEN));
+            => AvxIntrinsics.AddScaleU(DefaultScale, new Span<float>(src, 0, Length), new Span<float>(dst, 0, Length));
 
         [Benchmark]
         public void AddScaleSU()
-            => AvxIntrinsics.AddScaleSU(DEFAULT_SCALE, new Span<float>(src), new Span<int>(idx, 0, IDXLEN), new Span<float>(dst));
+            => AvxIntrinsics.AddScaleSU(DefaultScale, new Span<float>(src), new Span<int>(idx, 0, IndexLength), new Span<float>(dst));
 
         [Benchmark]
         public void AddScaleCopyU()
-            => AvxIntrinsics.AddScaleCopyU(DEFAULT_SCALE, new Span<float>(src, 0, LEN), new Span<float>(dst, 0, LEN), new Span<float>(result, 0, LEN));
+            => AvxIntrinsics.AddScaleCopyU(DefaultScale, new Span<float>(src, 0, Length), new Span<float>(dst, 0, Length), new Span<float>(result, 0, Length));
 
         [Benchmark]
         public void AddU()
-            => AvxIntrinsics.AddU(new Span<float>(src, 0, LEN), new Span<float>(dst, 0, LEN));
+            => AvxIntrinsics.AddU(new Span<float>(src, 0, Length), new Span<float>(dst, 0, Length));
 
         [Benchmark]
         public void AddSU()
-            => AvxIntrinsics.AddSU(new Span<float>(src), new Span<int>(idx, 0, IDXLEN), new Span<float>(dst));
+            => AvxIntrinsics.AddSU(new Span<float>(src), new Span<int>(idx, 0, IndexLength), new Span<float>(dst));
 
         [Benchmark]
         public void MulElementWiseU()
-            => AvxIntrinsics.MulElementWiseU(new Span<float>(src1, 0, LEN), new Span<float>(src2, 0, LEN),
-                                            new Span<float>(dst, 0, LEN));
+            => AvxIntrinsics.MulElementWiseU(new Span<float>(src1, 0, Length), new Span<float>(src2, 0, Length),
+                                            new Span<float>(dst, 0, Length));
 
         [Benchmark]
         public float SumU()
-            => AvxIntrinsics.SumU(new Span<float>(src, 0, LEN));
+            => AvxIntrinsics.SumU(new Span<float>(src, 0, Length));
 
         [Benchmark]
         public float SumSqU()
-            => AvxIntrinsics.SumSqU(new Span<float>(src, 0, LEN));
+            => AvxIntrinsics.SumSqU(new Span<float>(src, 0, Length));
 
         [Benchmark]
         public float SumSqDiffU()
-            => AvxIntrinsics.SumSqDiffU(DEFAULT_SCALE, new Span<float>(src, 0, LEN));
+            => AvxIntrinsics.SumSqDiffU(DefaultScale, new Span<float>(src, 0, Length));
 
        [Benchmark]
         public float SumAbsU()
-            => AvxIntrinsics.SumAbsU(new Span<float>(src, 0, LEN));
+            => AvxIntrinsics.SumAbsU(new Span<float>(src, 0, Length));
 
         [Benchmark]
         public float SumAbsDiffU()
-            => AvxIntrinsics.SumAbsDiffU(DEFAULT_SCALE, new Span<float>(src, 0, LEN));
+            => AvxIntrinsics.SumAbsDiffU(DefaultScale, new Span<float>(src, 0, Length));
 
         [Benchmark]
         public float MaxAbsU()
-            => AvxIntrinsics.MaxAbsU(new Span<float>(src, 0, LEN));
+            => AvxIntrinsics.MaxAbsU(new Span<float>(src, 0, Length));
 
         [Benchmark]
         public float MaxAbsDiffU()
-            => AvxIntrinsics.MaxAbsDiffU(DEFAULT_SCALE, new Span<float>(src, 0, LEN));
+            => AvxIntrinsics.MaxAbsDiffU(DefaultScale, new Span<float>(src, 0, Length));
 
         [Benchmark]
         public float DotU()
-            => AvxIntrinsics.DotU(new Span<float>(src, 0, LEN), new Span<float>(dst, 0, LEN));
+            => AvxIntrinsics.DotU(new Span<float>(src, 0, Length), new Span<float>(dst, 0, Length));
 
         [Benchmark]
         public float DotSU()
-            => AvxIntrinsics.DotSU(new Span<float>(src), new Span<float>(dst), new Span<int>(idx, 0, IDXLEN));
+            => AvxIntrinsics.DotSU(new Span<float>(src), new Span<float>(dst), new Span<int>(idx, 0, IndexLength));
 
         [Benchmark]
         public float Dist2()
-            => AvxIntrinsics.Dist2(new Span<float>(src, 0, LEN), new Span<float>(dst, 0, LEN));
+            => AvxIntrinsics.Dist2(new Span<float>(src, 0, Length), new Span<float>(dst, 0, Length));
 
         [Benchmark]
         public void SdcaL1UpdateU()
-            => AvxIntrinsics.SdcaL1UpdateU(DEFAULT_SCALE, new Span<float>(src, 0, LEN), DEFAULT_SCALE, new Span<float>(dst, 0, LEN), new Span<float>(result, 0, LEN));
+            => AvxIntrinsics.SdcaL1UpdateU(DefaultScale, new Span<float>(src, 0, Length), DefaultScale, new Span<float>(dst, 0, Length), new Span<float>(result, 0, Length));
 
         [Benchmark]
         public void SdcaL1UpdateSU()
-            => AvxIntrinsics.SdcaL1UpdateSU(DEFAULT_SCALE, new Span<float>(src, 0, IDXLEN), new Span<int>(idx, 0, IDXLEN), DEFAULT_SCALE, new Span<float>(dst), new Span<float>(result));
+            => AvxIntrinsics.SdcaL1UpdateSU(DefaultScale, new Span<float>(src, 0, IndexLength), new Span<int>(idx, 0, IndexLength), DefaultScale, new Span<float>(dst), new Span<float>(result));
     }
 }
diff --git a/test/Microsoft.ML.CpuMath.PerformanceTests/NativePerformanceTests.cs b/test/Microsoft.ML.CpuMath.PerformanceTests/NativePerformanceTests.cs
index b7eb3d233a..b992ed3001 100644
--- a/test/Microsoft.ML.CpuMath.PerformanceTests/NativePerformanceTests.cs
+++ b/test/Microsoft.ML.CpuMath.PerformanceTests/NativePerformanceTests.cs
@@ -16,7 +16,7 @@ public unsafe void AddScalarU()
         {
             fixed (float* pdst = dst)
             {
-                CpuMathNativeUtils.AddScalarU(DEFAULT_SCALE, pdst, LEN);
+                CpuMathNativeUtils.AddScalarU(DefaultScale, pdst, Length);
             }
         }
         
@@ -25,7 +25,7 @@ public unsafe void ScaleU()
         {
             fixed (float* pdst = dst)
             {
-                CpuMathNativeUtils.ScaleU(DEFAULT_SCALE, pdst, LEN);
+                CpuMathNativeUtils.ScaleU(DefaultScale, pdst, Length);
             }
         }
         
@@ -35,7 +35,7 @@ public unsafe void ScaleSrcU()
             fixed (float* psrc = src)
             fixed (float* pdst = dst)
             {
-                CpuMathNativeUtils.ScaleSrcU(DEFAULT_SCALE, psrc, pdst, LEN);
+                CpuMathNativeUtils.ScaleSrcU(DefaultScale, psrc, pdst, Length);
             }
         }
         
@@ -44,7 +44,7 @@ public unsafe void ScaleAddU()
         {
             fixed (float* pdst = dst)
             {
-                CpuMathNativeUtils.ScaleAddU(DEFAULT_SCALE, DEFAULT_SCALE, pdst, LEN);
+                CpuMathNativeUtils.ScaleAddU(DefaultScale, DefaultScale, pdst, Length);
             }
         }
         
@@ -54,7 +54,7 @@ public unsafe void AddScaleU()
             fixed (float* psrc = src)
             fixed (float* pdst = dst)
             {
-                CpuMathNativeUtils.AddScaleU(DEFAULT_SCALE, psrc, pdst, LEN);
+                CpuMathNativeUtils.AddScaleU(DefaultScale, psrc, pdst, Length);
             }
         }
         
@@ -65,7 +65,7 @@ public unsafe void AddScaleSU()
             fixed (float* pdst = dst)
             fixed (int* pidx = idx)
             {
-                CpuMathNativeUtils.AddScaleSU(DEFAULT_SCALE, psrc, pidx, pdst, IDXLEN);
+                CpuMathNativeUtils.AddScaleSU(DefaultScale, psrc, pidx, pdst, IndexLength);
             }
         }
         
@@ -76,7 +76,7 @@ public unsafe void AddScaleCopyU()
             fixed (float* pdst = dst)
             fixed (float* pres = result)
             {
-                CpuMathNativeUtils.AddScaleCopyU(DEFAULT_SCALE, psrc, pdst, pres, LEN);
+                CpuMathNativeUtils.AddScaleCopyU(DefaultScale, psrc, pdst, pres, Length);
             }
         }
         
@@ -86,7 +86,7 @@ public unsafe void AddU()
             fixed (float* psrc = src)
             fixed (float* pdst = dst)
             {
-                CpuMathNativeUtils.AddU(psrc, pdst, LEN);
+                CpuMathNativeUtils.AddU(psrc, pdst, Length);
             }
         }
         
@@ -97,7 +97,7 @@ public unsafe void AddSU()
             fixed (float* pdst = dst)
             fixed (int* pidx = idx)
             {
-                CpuMathNativeUtils.AddSU(psrc, pidx, pdst, IDXLEN);
+                CpuMathNativeUtils.AddSU(psrc, pidx, pdst, IndexLength);
             }
         }
         
@@ -108,7 +108,7 @@ public unsafe void MulElementWiseU()
             fixed (float* psrc2 = src2)
             fixed (float* pdst = dst)
             {
-                CpuMathNativeUtils.MulElementWiseU(psrc1, psrc2, pdst, LEN);
+                CpuMathNativeUtils.MulElementWiseU(psrc1, psrc2, pdst, Length);
             }
         }
         
@@ -117,7 +117,7 @@ public unsafe float SumU()
         {
             fixed (float* psrc = src)
             {
-                return CpuMathNativeUtils.SumU(psrc, LEN);
+                return CpuMathNativeUtils.SumU(psrc, Length);
             }
         }
         
@@ -126,7 +126,7 @@ public unsafe float SumSqU()
         {
             fixed (float* psrc = src)
             {
-                return CpuMathNativeUtils.SumSqU(psrc, LEN);
+                return CpuMathNativeUtils.SumSqU(psrc, Length);
             }
         }
         
@@ -135,7 +135,7 @@ public unsafe float SumSqDiffU()
         {
             fixed (float* psrc = src)
             {
-                return CpuMathNativeUtils.SumSqDiffU(DEFAULT_SCALE, psrc, LEN);
+                return CpuMathNativeUtils.SumSqDiffU(DefaultScale, psrc, Length);
             }
         }
         
@@ -144,7 +144,7 @@ public unsafe float SumAbsU()
         {
             fixed (float* psrc = src)
             {
-                return CpuMathNativeUtils.SumAbsU(psrc, LEN);
+                return CpuMathNativeUtils.SumAbsU(psrc, Length);
             }
         }
         
@@ -153,7 +153,7 @@ public unsafe float SumAbsDiffU()
         {
             fixed (float* psrc = src)
             {
-                return CpuMathNativeUtils.SumAbsDiffU(DEFAULT_SCALE, psrc, LEN);
+                return CpuMathNativeUtils.SumAbsDiffU(DefaultScale, psrc, Length);
             }
         }
         
@@ -162,7 +162,7 @@ public unsafe float MaxAbsU()
         {
             fixed (float* psrc = src)
             {
-                return CpuMathNativeUtils.MaxAbsU(psrc, LEN);
+                return CpuMathNativeUtils.MaxAbsU(psrc, Length);
             }
         }
         
@@ -171,7 +171,7 @@ public unsafe float MaxAbsDiffU()
         {
             fixed (float* psrc = src)
             {
-                return CpuMathNativeUtils.MaxAbsDiffU(DEFAULT_SCALE, psrc, LEN);
+                return CpuMathNativeUtils.MaxAbsDiffU(DefaultScale, psrc, Length);
             }
         }
         
@@ -181,7 +181,7 @@ public unsafe float DotU()
             fixed (float* psrc = src)
             fixed (float* pdst = dst)
             {
-                return CpuMathNativeUtils.DotU(psrc, pdst, LEN);
+                return CpuMathNativeUtils.DotU(psrc, pdst, Length);
             }
         }
         
@@ -192,7 +192,7 @@ public unsafe float DotSU()
             fixed (float* pdst = dst)
             fixed (int* pidx = idx)
             {
-                return CpuMathNativeUtils.DotSU(psrc, pdst, pidx, IDXLEN);
+                return CpuMathNativeUtils.DotSU(psrc, pdst, pidx, IndexLength);
             }
         }
 
@@ -202,7 +202,7 @@ public unsafe float Dist2()
             fixed (float* psrc = src)
             fixed (float* pdst = dst)
             {
-                return CpuMathNativeUtils.Dist2(psrc, pdst, LEN);
+                return CpuMathNativeUtils.Dist2(psrc, pdst, Length);
             }
         }
 
@@ -213,7 +213,7 @@ public unsafe void SdcaL1UpdateU()
             fixed (float* pdst = dst)
             fixed (float* pres = result)
             {
-                CpuMathNativeUtils.SdcaL1UpdateU(DEFAULT_SCALE, psrc, DEFAULT_SCALE, pdst, pres, LEN);
+                CpuMathNativeUtils.SdcaL1UpdateU(DefaultScale, psrc, DefaultScale, pdst, pres, Length);
             }
         }
 
@@ -225,7 +225,7 @@ public unsafe void SdcaL1UpdateSU()
             fixed (float* pres = result)
             fixed (int* pidx = idx)
             {
-                CpuMathNativeUtils.SdcaL1UpdateSU(DEFAULT_SCALE, psrc, pidx, DEFAULT_SCALE, pdst, pres, IDXLEN);
+                CpuMathNativeUtils.SdcaL1UpdateSU(DefaultScale, psrc, pidx, DefaultScale, pdst, pres, IndexLength);
             }
         }
     }
diff --git a/test/Microsoft.ML.CpuMath.PerformanceTests/PerformanceTests.cs b/test/Microsoft.ML.CpuMath.PerformanceTests/PerformanceTests.cs
index 1eb9157a2f..cffa0af94a 100644
--- a/test/Microsoft.ML.CpuMath.PerformanceTests/PerformanceTests.cs
+++ b/test/Microsoft.ML.CpuMath.PerformanceTests/PerformanceTests.cs
@@ -11,24 +11,20 @@ namespace Microsoft.ML.CpuMath.PerformanceTests
 {
     public abstract class PerformanceTests
     {
-        private const int EXP_MAX = 127;
-        private const int EXP_MIN = 0;
-        private const int EXP_RANGE = EXP_MAX / 8;
+        private const int ExponentMax = 127;
+        private const int ExponentMin = 0;
+        private const int ExponentRange = ExponentMax / 8;
 
-        protected const int IDXLEN = 1000003;
-        protected const int LEN = 1000003;
+        protected const int IndexLength = 1000003;
+        protected const int Length = 1000003;
         
-        private const int DEFAULT_SEED = 253421;
-        protected const float DEFAULT_SCALE = 1.11f;
-
-        protected const int DEFAULT_CROW = 500;
-        protected const int DEFAULT_CCOL = 2000;
-        protected const bool ADD = true;
+        private const int DefaultSeed = 253421;
+        protected const float DefaultScale = 1.11f;
 
         protected float[] src, dst, original, src1, src2, result;
         protected int[] idx;
 
-        private int seed = DEFAULT_SEED;
+        private int _seed = DefaultSeed;
 
         private float NextFloat(Random rand, int expRange)
         {
@@ -39,7 +35,7 @@ private float NextFloat(Random rand, int expRange)
 
         private int GetSeed()
         {
-            int seed = DEFAULT_SEED;
+            int seed = DefaultSeed;
             string CPUMATH_SEED = Environment.GetEnvironmentVariable("CPUMATH_SEED");
 
             if (CPUMATH_SEED != null)
@@ -52,7 +48,7 @@ private int GetSeed()
                     }
                     else
                     {
-                        seed = DEFAULT_SEED;
+                        seed = DefaultSeed;
                     }
                 }
             }
@@ -64,30 +60,30 @@ private int GetSeed()
         [GlobalSetup]
         public void Setup()
         {
-            src = new float[LEN];
-            dst = new float[LEN];
-            src1 = new float[LEN];
-            src2 = new float[LEN];
-            original = new float[LEN];
-            result = new float[LEN];
-            idx = new int[IDXLEN];
+            src = new float[Length];
+            dst = new float[Length];
+            src1 = new float[Length];
+            src2 = new float[Length];
+            original = new float[Length];
+            result = new float[Length];
+            idx = new int[IndexLength];
 
-            seed = GetSeed();
-            Random rand = new Random(seed);
+            _seed = GetSeed();
+            Random rand = new Random(_seed);
 
-            for (int i = 0; i < LEN; i++)
+            for (int i = 0; i < Length; i++)
             {
-                src[i] = NextFloat(rand, EXP_RANGE);
-                dst[i] = NextFloat(rand, EXP_RANGE);
+                src[i] = NextFloat(rand, ExponentRange);
+                dst[i] = NextFloat(rand, ExponentRange);
                 original[i] = dst[i];
                 result[i] = dst[i];
-                src1[i] = NextFloat(rand, EXP_RANGE);
-                src2[i] = NextFloat(rand, EXP_RANGE);
+                src1[i] = NextFloat(rand, ExponentRange);
+                src2[i] = NextFloat(rand, ExponentRange);
             }
 
-            for (int i = 0; i < IDXLEN; i++)
+            for (int i = 0; i < IndexLength; i++)
             {
-                idx[i] = rand.Next(0, LEN);
+                idx[i] = rand.Next(0, Length);
             }
         }
 
diff --git a/test/Microsoft.ML.CpuMath.PerformanceTests/SsePerformanceTests.cs b/test/Microsoft.ML.CpuMath.PerformanceTests/SsePerformanceTests.cs
index 21eb840bdc..046e065955 100644
--- a/test/Microsoft.ML.CpuMath.PerformanceTests/SsePerformanceTests.cs
+++ b/test/Microsoft.ML.CpuMath.PerformanceTests/SsePerformanceTests.cs
@@ -13,91 +13,91 @@ public class SsePerformanceTests : PerformanceTests
     {
         [Benchmark]
         public void AddScalarU()
-            => SseIntrinsics.AddScalarU(DEFAULT_SCALE, new Span<float>(dst, 0, LEN));
+            => SseIntrinsics.AddScalarU(DefaultScale, new Span<float>(dst, 0, Length));
         
         [Benchmark]
         public void ScaleU()
-            => SseIntrinsics.ScaleU(DEFAULT_SCALE, new Span<float>(dst, 0, LEN));
+            => SseIntrinsics.ScaleU(DefaultScale, new Span<float>(dst, 0, Length));
         
         [Benchmark]
         public void ScaleSrcU()
-            => SseIntrinsics.ScaleSrcU(DEFAULT_SCALE, new Span<float>(src, 0, LEN), new Span<float>(dst, 0, LEN));
+            => SseIntrinsics.ScaleSrcU(DefaultScale, new Span<float>(src, 0, Length), new Span<float>(dst, 0, Length));
 
         [Benchmark]
         public void ScaleAddU()
-            => SseIntrinsics.ScaleAddU(DEFAULT_SCALE, DEFAULT_SCALE, new Span<float>(dst, 0, LEN));
+            => SseIntrinsics.ScaleAddU(DefaultScale, DefaultScale, new Span<float>(dst, 0, Length));
         
         [Benchmark]
         public void AddScaleU()
-            => SseIntrinsics.AddScaleU(DEFAULT_SCALE, new Span<float>(src, 0, LEN), new Span<float>(dst, 0, LEN));
+            => SseIntrinsics.AddScaleU(DefaultScale, new Span<float>(src, 0, Length), new Span<float>(dst, 0, Length));
 
         [Benchmark]
         public void AddScaleSU()
-            => SseIntrinsics.AddScaleSU(DEFAULT_SCALE, new Span<float>(src), new Span<int>(idx, 0, IDXLEN), new Span<float>(dst));
+            => SseIntrinsics.AddScaleSU(DefaultScale, new Span<float>(src), new Span<int>(idx, 0, IndexLength), new Span<float>(dst));
 
         [Benchmark]
         public void AddScaleCopyU()
-            => SseIntrinsics.AddScaleCopyU(DEFAULT_SCALE, new Span<float>(src, 0, LEN), new Span<float>(dst, 0, LEN), new Span<float>(result, 0, LEN));
+            => SseIntrinsics.AddScaleCopyU(DefaultScale, new Span<float>(src, 0, Length), new Span<float>(dst, 0, Length), new Span<float>(result, 0, Length));
 
         [Benchmark]
         public void AddU()
-            => SseIntrinsics.AddU(new Span<float>(src, 0, LEN), new Span<float>(dst, 0, LEN));
+            => SseIntrinsics.AddU(new Span<float>(src, 0, Length), new Span<float>(dst, 0, Length));
 
         [Benchmark]
         public void AddSU()
-            => SseIntrinsics.AddSU(new Span<float>(src), new Span<int>(idx, 0, IDXLEN), new Span<float>(dst));
+            => SseIntrinsics.AddSU(new Span<float>(src), new Span<int>(idx, 0, IndexLength), new Span<float>(dst));
 
         [Benchmark]
         public void MulElementWiseU()
-            => SseIntrinsics.MulElementWiseU(new Span<float>(src1, 0, LEN), new Span<float>(src2, 0, LEN),
-                                            new Span<float>(dst, 0, LEN));
+            => SseIntrinsics.MulElementWiseU(new Span<float>(src1, 0, Length), new Span<float>(src2, 0, Length),
+                                            new Span<float>(dst, 0, Length));
 
         [Benchmark]
         public float SumU()
-            => SseIntrinsics.SumU(new Span<float>(src, 0, LEN));
+            => SseIntrinsics.SumU(new Span<float>(src, 0, Length));
 
         [Benchmark]
         public float SumSqU()
-            => SseIntrinsics.SumSqU(new Span<float>(src, 0, LEN));
+            => SseIntrinsics.SumSqU(new Span<float>(src, 0, Length));
         
         [Benchmark]
         public float SumSqDiffU()
-            => SseIntrinsics.SumSqDiffU(DEFAULT_SCALE, new Span<float>(src, 0, LEN));
+            => SseIntrinsics.SumSqDiffU(DefaultScale, new Span<float>(src, 0, Length));
         
         [Benchmark]
         public float SumAbsU()
-            => SseIntrinsics.SumAbsU(new Span<float>(src, 0, LEN));
+            => SseIntrinsics.SumAbsU(new Span<float>(src, 0, Length));
 
         [Benchmark]
         public float SumAbsDiffU()
-            => SseIntrinsics.SumAbsDiffU(DEFAULT_SCALE, new Span<float>(src, 0, LEN));
+            => SseIntrinsics.SumAbsDiffU(DefaultScale, new Span<float>(src, 0, Length));
         
         [Benchmark]
         public float MaxAbsU()
-            => SseIntrinsics.MaxAbsU(new Span<float>(src, 0, LEN));
+            => SseIntrinsics.MaxAbsU(new Span<float>(src, 0, Length));
         
         [Benchmark]
         public float MaxAbsDiffU()
-            => SseIntrinsics.MaxAbsDiffU(DEFAULT_SCALE, new Span<float>(src, 0, LEN));
+            => SseIntrinsics.MaxAbsDiffU(DefaultScale, new Span<float>(src, 0, Length));
         
         [Benchmark]
         public float DotU()
-            => SseIntrinsics.DotU(new Span<float>(src, 0, LEN), new Span<float>(dst, 0, LEN));
+            => SseIntrinsics.DotU(new Span<float>(src, 0, Length), new Span<float>(dst, 0, Length));
         
         [Benchmark]
         public float DotSU()
-            => SseIntrinsics.DotSU(new Span<float>(src), new Span<float>(dst), new Span<int>(idx, 0, IDXLEN));
+            => SseIntrinsics.DotSU(new Span<float>(src), new Span<float>(dst), new Span<int>(idx, 0, IndexLength));
         
         [Benchmark]
         public float Dist2()
-            => SseIntrinsics.Dist2(new Span<float>(src, 0, LEN), new Span<float>(dst, 0, LEN));
+            => SseIntrinsics.Dist2(new Span<float>(src, 0, Length), new Span<float>(dst, 0, Length));
 
         [Benchmark]
         public void SdcaL1UpdateU()
-            => SseIntrinsics.SdcaL1UpdateU(DEFAULT_SCALE, new Span<float>(src, 0, LEN), DEFAULT_SCALE, new Span<float>(dst, 0, LEN), new Span<float>(result, 0, LEN));
+            => SseIntrinsics.SdcaL1UpdateU(DefaultScale, new Span<float>(src, 0, Length), DefaultScale, new Span<float>(dst, 0, Length), new Span<float>(result, 0, Length));
 
         [Benchmark]
         public void SdcaL1UpdateSU()
-            => SseIntrinsics.SdcaL1UpdateSU(DEFAULT_SCALE, new Span<float>(src, 0, IDXLEN), new Span<int>(idx, 0, IDXLEN), DEFAULT_SCALE, new Span<float>(dst), new Span<float>(result));
+            => SseIntrinsics.SdcaL1UpdateSU(DefaultScale, new Span<float>(src, 0, IndexLength), new Span<int>(idx, 0, IndexLength), DefaultScale, new Span<float>(dst), new Span<float>(result));
     }
 }
diff --git a/test/Microsoft.ML.CpuMath.UnitTests.netcoreapp/UnitTests.cs b/test/Microsoft.ML.CpuMath.UnitTests.netcoreapp/UnitTests.cs
index 1877ebe6b0..7284ce6c1a 100644
--- a/test/Microsoft.ML.CpuMath.UnitTests.netcoreapp/UnitTests.cs
+++ b/test/Microsoft.ML.CpuMath.UnitTests.netcoreapp/UnitTests.cs
@@ -21,7 +21,7 @@ public class CpuMathUtilsUnitTests
         private readonly FloatEqualityComparer _comparer;
         private readonly FloatEqualityComparerForMatMul _matMulComparer;
 
-        private const float DEFAULT_SCALE = 1.7f;
+        private const float DefaultScale = 1.7f;
 
         public CpuMathUtilsUnitTests()
         {
@@ -222,10 +222,10 @@ public void AddScalarUTest(int test)
 
             for (int i = 0; i < expected.Length; i++)
             {
-                expected[i] += DEFAULT_SCALE;
+                expected[i] += DefaultScale;
             }
 
-            CpuMathUtils.Add(DEFAULT_SCALE, dst, dst.Length);
+            CpuMathUtils.Add(DefaultScale, dst, dst.Length);
             var actual = dst;
             Assert.Equal(expected, actual, _comparer);
         }
@@ -240,10 +240,10 @@ public void ScaleUTest(int test)
 
             for (int i = 0; i < expected.Length; i++)
             {
-                expected[i] *= DEFAULT_SCALE;
+                expected[i] *= DefaultScale;
             }
 
-            CpuMathUtils.Scale(DEFAULT_SCALE, dst, dst.Length);
+            CpuMathUtils.Scale(DefaultScale, dst, dst.Length);
             var actual = dst;
             Assert.Equal(expected, actual, _comparer);
         }
@@ -259,10 +259,10 @@ public void ScaleSrcUTest(int test)
 
             for (int i = 0; i < expected.Length; i++)
             {
-                expected[i] *= DEFAULT_SCALE;
+                expected[i] *= DefaultScale;
             }
 
-            CpuMathUtils.Scale(DEFAULT_SCALE, src, dst, dst.Length);
+            CpuMathUtils.Scale(DefaultScale, src, dst, dst.Length);
             var actual = dst;
             Assert.Equal(expected, actual, _comparer);
         }
@@ -277,10 +277,10 @@ public void ScaleAddUTest(int test)
 
             for (int i = 0; i < expected.Length; i++)
             {
-                expected[i] = DEFAULT_SCALE * (dst[i] + DEFAULT_SCALE);
+                expected[i] = DefaultScale * (dst[i] + DefaultScale);
             }
 
-            CpuMathUtils.ScaleAdd(DEFAULT_SCALE, DEFAULT_SCALE, dst, dst.Length);
+            CpuMathUtils.ScaleAdd(DefaultScale, DefaultScale, dst, dst.Length);
             var actual = dst;
             Assert.Equal(expected, actual, _comparer);
         }
@@ -296,10 +296,10 @@ public void AddScaleUTest(int test)
 
             for (int i = 0; i < expected.Length; i++)
             {
-                expected[i] *= (1 + DEFAULT_SCALE);
+                expected[i] *= (1 + DefaultScale);
             }
 
-            CpuMathUtils.AddScale(DEFAULT_SCALE, src, dst, dst.Length);
+            CpuMathUtils.AddScale(DefaultScale, src, dst, dst.Length);
             var actual = dst;
             Assert.Equal(expected, actual, _comparer);
         }
@@ -324,7 +324,7 @@ public void AddScaleSUTest(int test)
             expected[13] = -21.337f;
             expected[14] = 35.782f;
 
-            CpuMathUtils.AddScale(DEFAULT_SCALE, src, idx, dst, idx.Length);
+            CpuMathUtils.AddScale(DefaultScale, src, idx, dst, idx.Length);
             var actual = dst;
             Assert.Equal(expected, actual, _comparer);
         }
@@ -341,10 +341,10 @@ public void AddScaleCopyUTest(int test)
 
             for (int i = 0; i < expected.Length; i++)
             {
-                expected[i] *= (1 + DEFAULT_SCALE);
+                expected[i] *= (1 + DefaultScale);
             }
 
-            CpuMathUtils.AddScaleCopy(DEFAULT_SCALE, src, dst, result, dst.Length);
+            CpuMathUtils.AddScaleCopy(DefaultScale, src, dst, result, dst.Length);
             var actual = result;
             Assert.Equal(expected, actual, _comparer);
         }
@@ -452,7 +452,7 @@ public void SumSqUTest(int test, float expected)
         public void SumSqDiffUTest(int test, float expected)
         {
             float[] src = (float[])_testArrays[test].Clone();
-            var actual = CpuMathUtils.SumSq(DEFAULT_SCALE, src, 0, src.Length);
+            var actual = CpuMathUtils.SumSq(DefaultScale, src, 0, src.Length);
             Assert.Equal(expected, actual, 2);
         }
 
@@ -472,7 +472,7 @@ public void SumAbsUTest(int test, float expected)
         public void SumAbsDiffUTest(int test, float expected)
         {
             float[] src = (float[])_testArrays[test].Clone();
-            var actual = CpuMathUtils.SumAbs(DEFAULT_SCALE, src, 0, src.Length);
+            var actual = CpuMathUtils.SumAbs(DefaultScale, src, 0, src.Length);
             Assert.Equal(expected, actual, 2);
         }
 
@@ -492,7 +492,7 @@ public void MaxAbsUTest(int test, float expected)
         public void MaxAbsDiffUTest(int test, float expected)
         {
             float[] src = (float[])_testArrays[test].Clone();
-            var actual = CpuMathUtils.MaxAbsDiff(DEFAULT_SCALE, src, src.Length);
+            var actual = CpuMathUtils.MaxAbsDiff(DefaultScale, src, src.Length);
             Assert.Equal(expected, actual, 2);
         }
 
@@ -590,11 +590,11 @@ public void SdcaL1UpdateUTest(int test)
 
             for (int i = 0; i < expected.Length; i++)
             {
-                float value = src[i] * (1 + DEFAULT_SCALE);
-                expected[i] = Math.Abs(value) > DEFAULT_SCALE ? (value > 0 ? value - DEFAULT_SCALE : value + DEFAULT_SCALE) : 0;
+                float value = src[i] * (1 + DefaultScale);
+                expected[i] = Math.Abs(value) > DefaultScale ? (value > 0 ? value - DefaultScale : value + DefaultScale) : 0;
             }
 
-            CpuMathUtils.SdcaL1UpdateDense(DEFAULT_SCALE, src.Length, src, DEFAULT_SCALE, v, w);
+            CpuMathUtils.SdcaL1UpdateDense(DefaultScale, src.Length, src, DefaultScale, v, w);
             var actual = w;
             Assert.Equal(expected, actual, _comparer);
         }
@@ -613,11 +613,11 @@ public void SdcaL1UpdateSUTest(int test)
             for (int i = 0; i < idx.Length; i++)
             {
                 int index = idx[i];
-                float value = v[index] + src[i] * DEFAULT_SCALE;
-                expected[index] = Math.Abs(value) > DEFAULT_SCALE ? (value > 0 ? value - DEFAULT_SCALE : value + DEFAULT_SCALE) : 0;
+                float value = v[index] + src[i] * DefaultScale;
+                expected[index] = Math.Abs(value) > DefaultScale ? (value > 0 ? value - DefaultScale : value + DefaultScale) : 0;
             }
 
-            CpuMathUtils.SdcaL1UpdateSparse(DEFAULT_SCALE, src.Length, src, idx, idx.Length, DEFAULT_SCALE, v, w);
+            CpuMathUtils.SdcaL1UpdateSparse(DefaultScale, src.Length, src, idx, idx.Length, DefaultScale, v, w);
             var actual = w;
             Assert.Equal(expected, actual, _comparer);
         }