JakeRadMSFT · JakeRadMSFT · commit d8872b290c66 · 2023-05-08T22:16:33.000-07:00
Clean up variables and consistency
diff --git a/src/Microsoft.Data.Analysis/NumberMathComputation.cs b/src/Microsoft.Data.Analysis/NumberMathComputation.cs
@@ -33,7 +33,7 @@ public void Any(PrimitiveColumnContainer<T> column, out bool ret)
 
         public void CumulativeMax(PrimitiveColumnContainer<T> column)
         {
-            CumulativeApply(column, T.Max);
+            CumulativeApply(column, T.Max, column.Buffers[0].ReadOnlySpan[0]);
         }
 
         public void CumulativeMax(PrimitiveColumnContainer<T> column, IEnumerable<long> rows)
@@ -43,7 +43,7 @@ public void CumulativeMax(PrimitiveColumnContainer<T> column, IEnumerable<long>
 
         public void CumulativeMin(PrimitiveColumnContainer<T> column)
         {
-            CumulativeApply(column, T.Min);
+            CumulativeApply(column, T.Min, column.Buffers[0].ReadOnlySpan[0]);
         }
 
         public void CumulativeMin(PrimitiveColumnContainer<T> column, IEnumerable<long> rows)
@@ -139,55 +139,41 @@ protected void Apply(PrimitiveColumnContainer<T> column, Func<T, T> func)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
             {
-                var buffer = column.Buffers[b];
-                var mutableBuffer = DataFrameBuffer<T>.GetMutableBuffer(buffer);
-                var mutableSpan = mutableBuffer.Span;
-
-                var nullBitMapBuffer = column.NullBitMapBuffers[b].ReadOnlySpan;
-                for (int i = 0; i < mutableSpan.Length; i++)
+                var buffer = column.Buffers.GetOrCreateMutable(b).Span;
+                var bitmap = column.NullBitMapBuffers[b].ReadOnlySpan;
+                for (int i = 0; i < buffer.Length; i++)
                 {
-                    if (column.IsValid(nullBitMapBuffer, i))
+                    if (column.IsValid(bitmap, i))
                     {
-                        mutableSpan[i] = func(mutableSpan[i]);
+                        buffer[i] = func(buffer[i]);
                     }
                 }
-                column.Buffers[b] = mutableBuffer;
             }
         }
 
-        protected void CumulativeApply(PrimitiveColumnContainer<T> column, Func<T, T, T> func)
-        {
-            CumulativeApply(column, func, column.Buffers[0].ReadOnlySpan[0]);
-        }
-
         protected void CumulativeApply(PrimitiveColumnContainer<T> column, Func<T, T, T> func, T startingValue)
         {
             T ret = startingValue;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
-                var buffer = column.Buffers[b];
-                var mutableBuffer = DataFrameBuffer<T>.GetMutableBuffer(buffer);
-                var mutableSpan = mutableBuffer.Span;
-
-                var nullBitMapBuffer = column.NullBitMapBuffers[b].ReadOnlySpan;
-                for (int i = 0; i < mutableSpan.Length; i++)
+                var buffer = column.Buffers.GetOrCreateMutable(b).Span;
+                var bitmap = column.NullBitMapBuffers[b].ReadOnlySpan;
+                for (int i = 0; i < buffer.Length; i++)
                 {
-                    if (column.IsValid(nullBitMapBuffer, i))
+                    if (column.IsValid(bitmap, i))
                     {
-                        ret = func(mutableSpan[i], ret);
-                        mutableSpan[i] = ret;
+                        ret = func(buffer[i], ret);
+                        buffer[i] = ret;
                     }
                 }
-                column.Buffers[b] = mutableBuffer;
             }
         }
 
         protected void CumulativeApply(PrimitiveColumnContainer<T> column, Func<T, T, T> func, IEnumerable<long> rows)
         {
             T ret = T.Zero;
-            var mutableBuffer = column.Buffers.GetOrCreateMutable(0);
-            var nullBitMap = column.NullBitMapBuffers.GetOrCreateMutable(0);
-            var span = mutableBuffer.Span;
+            var buffer = column.Buffers.GetOrCreateMutable(0).Span;
+            var bitmap = column.NullBitMapBuffers[0].ReadOnlySpan;
             long minRange = 0;
             long maxRange = ReadOnlyDataFrameBuffer<T>.MaxCapacity;
             long maxCapacity = maxRange;
@@ -200,18 +186,17 @@ protected void CumulativeApply(PrimitiveColumnContainer<T> column, Func<T, T, T>
                 if (row < minRange || row >= maxRange)
                 {
                     int bufferIndex = (int)(row / maxCapacity);
-                    mutableBuffer = column.Buffers.GetOrCreateMutable(bufferIndex);
-                    nullBitMap = column.NullBitMapBuffers.GetOrCreateMutable(bufferIndex);
-                    span = mutableBuffer.Span;
+                    buffer = column.Buffers.GetOrCreateMutable(bufferIndex).Span;
+                    bitmap = column.NullBitMapBuffers[bufferIndex].ReadOnlySpan;
                     minRange = checked(bufferIndex * maxCapacity);
                     maxRange = checked((bufferIndex + 1) * maxCapacity);
                 }
 
                 row -= minRange;
-                if (column.IsValid(nullBitMap.Span, (int)row))
+                if (column.IsValid(bitmap, (int)row))
                 {
                     isValid = true;
-                    ret = span[(int)row];
+                    ret = buffer[(int)row];
                 }
             }
 
@@ -221,18 +206,17 @@ protected void CumulativeApply(PrimitiveColumnContainer<T> column, Func<T, T, T>
                 if (row < minRange || row >= maxRange)
                 {
                     int bufferIndex = (int)(row / maxCapacity);
-                    mutableBuffer = column.Buffers.GetOrCreateMutable(bufferIndex);
-                    nullBitMap = column.NullBitMapBuffers.GetOrCreateMutable(bufferIndex);
-                    span = mutableBuffer.Span;
+                    buffer = column.Buffers.GetOrCreateMutable(bufferIndex).Span;
+                    bitmap = column.NullBitMapBuffers[bufferIndex].ReadOnlySpan;
                     minRange = checked(bufferIndex * maxCapacity);
                     maxRange = checked((bufferIndex + 1) * maxCapacity);
                 }
 
                 row -= minRange;
-                if (column.IsValid(nullBitMapBuffer, i))
+                if (column.IsValid(bitmap, (int)row))
                 {
-                    ret = func(ret, readonlySpan[i]);
-                    span[(int)row] = ret;
+                    ret = func(ret, buffer[(int)row]);
+                    buffer[(int)row] = ret;
                 }
             }
         }
@@ -244,13 +228,13 @@ protected T CalculateReduction(PrimitiveColumnContainer<T> column, Func<T, T, T>
 
             for (int b = 0; b < column.Buffers.Count; b++)
             {
-                var readonlySpan = column.Buffers[b].ReadOnlySpan;
-                var nullBitMapBuffer = column.NullBitMapBuffers[b].ReadOnlySpan;
-                for (int i = 0; i < readonlySpan.Length; i++)
+                var buffer = column.Buffers[b].ReadOnlySpan;
+                var bitMap = column.NullBitMapBuffers[b].ReadOnlySpan;
+                for (int i = 0; i < buffer.Length; i++)
                 {
-                    if (column.IsValid(nullBitMapBuffer, i))
+                    if (column.IsValid(bitMap, i))
                     {
-                        ret = func(ret, readonlySpan[i]);
+                        ret = checked(func(ret, buffer[i]));
                     }
                 }
             }
@@ -260,8 +244,8 @@ protected T CalculateReduction(PrimitiveColumnContainer<T> column, Func<T, T, T>
         protected T CalculateReduction(PrimitiveColumnContainer<T> column, Func<T, T, T> func, IEnumerable<long> rows)
         {
             var ret = T.Zero;
-            var readOnlySpan = column.Buffers[0].ReadOnlySpan;
-            var readOnlyNullBitMap = column.NullBitMapBuffers[0].ReadOnlySpan;
+            var buffer = column.Buffers[0].ReadOnlySpan;
+            var bitMap = column.NullBitMapBuffers[0].ReadOnlySpan;
             long minRange = 0;
             long maxRange = ReadOnlyDataFrameBuffer<T>.MaxCapacity;
             long maxCapacity = maxRange;
@@ -274,17 +258,17 @@ protected T CalculateReduction(PrimitiveColumnContainer<T> column, Func<T, T, T>
                 if (row < minRange || row >= maxRange)
                 {
                     int bufferIndex = (int)(row / maxCapacity);
-                    readOnlySpan = column.Buffers[bufferIndex].ReadOnlySpan;
-                    readOnlyNullBitMap = column.NullBitMapBuffers[bufferIndex].ReadOnlySpan;
+                    buffer = column.Buffers[bufferIndex].ReadOnlySpan;
+                    bitMap = column.NullBitMapBuffers[bufferIndex].ReadOnlySpan;
                     minRange = checked(bufferIndex * maxCapacity);
                     maxRange = checked((bufferIndex + 1) * maxCapacity);
                 }
                 row -= minRange;
 
-                if (column.IsValid(readOnlyNullBitMap, (int)row))
+                if (column.IsValid(bitMap, (int)row))
                 {
                     isValid = true;
-                    ret = readOnlySpan[(int)row];
+                    ret = buffer[(int)row];
                 }
             }
 
@@ -294,14 +278,18 @@ protected T CalculateReduction(PrimitiveColumnContainer<T> column, Func<T, T, T>
                 if (row < minRange || row >= maxRange)
                 {
                     int bufferIndex = (int)(row / maxCapacity);
-                    readOnlySpan = column.Buffers[bufferIndex].ReadOnlySpan;
-                    readOnlyNullBitMap = column.NullBitMapBuffers[bufferIndex].ReadOnlySpan;
+                    buffer = column.Buffers[bufferIndex].ReadOnlySpan;
+                    bitMap = column.NullBitMapBuffers[bufferIndex].ReadOnlySpan;
                     minRange = checked(bufferIndex * maxCapacity);
                     maxRange = checked((bufferIndex + 1) * maxCapacity);
                 }
                 row -= minRange;
 
-                ret = checked(func(readOnlySpan[(int)row], ret));
+                if (column.IsValid(bitMap, (int)row))
+                {
+                    ret = checked(func(ret, buffer[(int)row]));
+                }
+
             }
 
             return ret;

Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public void Any(PrimitiveColumnContainer<T> column, out bool ret)`
`33`	`33`
`34`	`34`	`public void CumulativeMax(PrimitiveColumnContainer<T> column)`
`35`	`35`	`{`
`36`		`- CumulativeApply(column, T.Max);`
	`36`	`+ CumulativeApply(column, T.Max, column.Buffers[0].ReadOnlySpan[0]);`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`public void CumulativeMax(PrimitiveColumnContainer<T> column, IEnumerable<long> rows)`
`@@ -43,7 +43,7 @@ public void CumulativeMax(PrimitiveColumnContainer<T> column, IEnumerable<long>`
`43`	`43`
`44`	`44`	`public void CumulativeMin(PrimitiveColumnContainer<T> column)`
`45`	`45`	`{`
`46`		`- CumulativeApply(column, T.Min);`
	`46`	`+ CumulativeApply(column, T.Min, column.Buffers[0].ReadOnlySpan[0]);`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`public void CumulativeMin(PrimitiveColumnContainer<T> column, IEnumerable<long> rows)`
`@@ -139,55 +139,41 @@ protected void Apply(PrimitiveColumnContainer<T> column, Func<T, T> func)`
`139`	`139`	`{`
`140`	`140`	`for (int b = 0; b < column.Buffers.Count; b++)`
`141`	`141`	`{`
`142`		`- var buffer = column.Buffers[b];`
`143`		`- var mutableBuffer = DataFrameBuffer<T>.GetMutableBuffer(buffer);`
`144`		`- var mutableSpan = mutableBuffer.Span;`
`145`		`-`
`146`		`- var nullBitMapBuffer = column.NullBitMapBuffers[b].ReadOnlySpan;`
`147`		`- for (int i = 0; i < mutableSpan.Length; i++)`
	`142`	`+ var buffer = column.Buffers.GetOrCreateMutable(b).Span;`
	`143`	`+ var bitmap = column.NullBitMapBuffers[b].ReadOnlySpan;`
	`144`	`+ for (int i = 0; i < buffer.Length; i++)`
`148`	`145`	`{`
`149`		`- if (column.IsValid(nullBitMapBuffer, i))`
	`146`	`+ if (column.IsValid(bitmap, i))`
`150`	`147`	`{`
`151`		`- mutableSpan[i] = func(mutableSpan[i]);`
	`148`	`+ buffer[i] = func(buffer[i]);`
`152`	`149`	`}`
`153`	`150`	`}`
`154`		`- column.Buffers[b] = mutableBuffer;`
`155`	`151`	`}`
`156`	`152`	`}`
`157`	`153`
`158`		`- protected void CumulativeApply(PrimitiveColumnContainer<T> column, Func<T, T, T> func)`
`159`		`- {`
`160`		`- CumulativeApply(column, func, column.Buffers[0].ReadOnlySpan[0]);`
`161`		`- }`
`162`		`-`
`163`	`154`	`protected void CumulativeApply(PrimitiveColumnContainer<T> column, Func<T, T, T> func, T startingValue)`
`164`	`155`	`{`
`165`	`156`	`T ret = startingValue;`
`166`	`157`	`for (int b = 0; b < column.Buffers.Count; b++)`
`167`	`158`	`{`
`168`		`- var buffer = column.Buffers[b];`
`169`		`- var mutableBuffer = DataFrameBuffer<T>.GetMutableBuffer(buffer);`
`170`		`- var mutableSpan = mutableBuffer.Span;`
`171`		`-`
`172`		`- var nullBitMapBuffer = column.NullBitMapBuffers[b].ReadOnlySpan;`
`173`		`- for (int i = 0; i < mutableSpan.Length; i++)`
	`159`	`+ var buffer = column.Buffers.GetOrCreateMutable(b).Span;`
	`160`	`+ var bitmap = column.NullBitMapBuffers[b].ReadOnlySpan;`
	`161`	`+ for (int i = 0; i < buffer.Length; i++)`
`174`	`162`	`{`
`175`		`- if (column.IsValid(nullBitMapBuffer, i))`
	`163`	`+ if (column.IsValid(bitmap, i))`
`176`	`164`	`{`
`177`		`- ret = func(mutableSpan[i], ret);`
`178`		`- mutableSpan[i] = ret;`
	`165`	`+ ret = func(buffer[i], ret);`
	`166`	`+ buffer[i] = ret;`
`179`	`167`	`}`
`180`	`168`	`}`
`181`		`- column.Buffers[b] = mutableBuffer;`
`182`	`169`	`}`
`183`	`170`	`}`
`184`	`171`
`185`	`172`	`protected void CumulativeApply(PrimitiveColumnContainer<T> column, Func<T, T, T> func, IEnumerable<long> rows)`
`186`	`173`	`{`
`187`	`174`	`T ret = T.Zero;`
`188`		`- var mutableBuffer = column.Buffers.GetOrCreateMutable(0);`
`189`		`- var nullBitMap = column.NullBitMapBuffers.GetOrCreateMutable(0);`
`190`		`- var span = mutableBuffer.Span;`
	`175`	`+ var buffer = column.Buffers.GetOrCreateMutable(0).Span;`
	`176`	`+ var bitmap = column.NullBitMapBuffers[0].ReadOnlySpan;`
`191`	`177`	`long minRange = 0;`
`192`	`178`	`long maxRange = ReadOnlyDataFrameBuffer<T>.MaxCapacity;`
`193`	`179`	`long maxCapacity = maxRange;`
`@@ -200,18 +186,17 @@ protected void CumulativeApply(PrimitiveColumnContainer<T> column, Func<T, T, T>`
`200`	`186`	`if (row < minRange \|\| row >= maxRange)`
`201`	`187`	`{`
`202`	`188`	`int bufferIndex = (int)(row / maxCapacity);`
`203`		`- mutableBuffer = column.Buffers.GetOrCreateMutable(bufferIndex);`
`204`		`- nullBitMap = column.NullBitMapBuffers.GetOrCreateMutable(bufferIndex);`
`205`		`- span = mutableBuffer.Span;`
	`189`	`+ buffer = column.Buffers.GetOrCreateMutable(bufferIndex).Span;`
	`190`	`+ bitmap = column.NullBitMapBuffers[bufferIndex].ReadOnlySpan;`
`206`	`191`	`minRange = checked(bufferIndex * maxCapacity);`
`207`	`192`	`maxRange = checked((bufferIndex + 1) * maxCapacity);`
`208`	`193`	`}`
`209`	`194`
`210`	`195`	`row -= minRange;`
`211`		`- if (column.IsValid(nullBitMap.Span, (int)row))`
	`196`	`+ if (column.IsValid(bitmap, (int)row))`
`212`	`197`	`{`
`213`	`198`	`isValid = true;`
`214`		`- ret = span[(int)row];`
	`199`	`+ ret = buffer[(int)row];`
`215`	`200`	`}`
`216`	`201`	`}`
`217`	`202`
`@@ -221,18 +206,17 @@ protected void CumulativeApply(PrimitiveColumnContainer<T> column, Func<T, T, T>`
`221`	`206`	`if (row < minRange \|\| row >= maxRange)`
`222`	`207`	`{`
`223`	`208`	`int bufferIndex = (int)(row / maxCapacity);`
`224`		`- mutableBuffer = column.Buffers.GetOrCreateMutable(bufferIndex);`
`225`		`- nullBitMap = column.NullBitMapBuffers.GetOrCreateMutable(bufferIndex);`
`226`		`- span = mutableBuffer.Span;`
	`209`	`+ buffer = column.Buffers.GetOrCreateMutable(bufferIndex).Span;`
	`210`	`+ bitmap = column.NullBitMapBuffers[bufferIndex].ReadOnlySpan;`
`227`	`211`	`minRange = checked(bufferIndex * maxCapacity);`
`228`	`212`	`maxRange = checked((bufferIndex + 1) * maxCapacity);`
`229`	`213`	`}`
`230`	`214`
`231`	`215`	`row -= minRange;`
`232`		`- if (column.IsValid(nullBitMapBuffer, i))`
	`216`	`+ if (column.IsValid(bitmap, (int)row))`
`233`	`217`	`{`
`234`		`- ret = func(ret, readonlySpan[i]);`
`235`		`- span[(int)row] = ret;`
	`218`	`+ ret = func(ret, buffer[(int)row]);`
	`219`	`+ buffer[(int)row] = ret;`
`236`	`220`	`}`
`237`	`221`	`}`
`238`	`222`	`}`
`@@ -244,13 +228,13 @@ protected T CalculateReduction(PrimitiveColumnContainer<T> column, Func<T, T, T>`
`244`	`228`
`245`	`229`	`for (int b = 0; b < column.Buffers.Count; b++)`
`246`	`230`	`{`
`247`		`- var readonlySpan = column.Buffers[b].ReadOnlySpan;`
`248`		`- var nullBitMapBuffer = column.NullBitMapBuffers[b].ReadOnlySpan;`
`249`		`- for (int i = 0; i < readonlySpan.Length; i++)`
	`231`	`+ var buffer = column.Buffers[b].ReadOnlySpan;`
	`232`	`+ var bitMap = column.NullBitMapBuffers[b].ReadOnlySpan;`
	`233`	`+ for (int i = 0; i < buffer.Length; i++)`
`250`	`234`	`{`
`251`		`- if (column.IsValid(nullBitMapBuffer, i))`
	`235`	`+ if (column.IsValid(bitMap, i))`
`252`	`236`	`{`
`253`		`- ret = func(ret, readonlySpan[i]);`
	`237`	`+ ret = checked(func(ret, buffer[i]));`
`254`	`238`	`}`
`255`	`239`	`}`
`256`	`240`	`}`
`@@ -260,8 +244,8 @@ protected T CalculateReduction(PrimitiveColumnContainer<T> column, Func<T, T, T>`
`260`	`244`	`protected T CalculateReduction(PrimitiveColumnContainer<T> column, Func<T, T, T> func, IEnumerable<long> rows)`
`261`	`245`	`{`
`262`	`246`	`var ret = T.Zero;`
`263`		`- var readOnlySpan = column.Buffers[0].ReadOnlySpan;`
`264`		`- var readOnlyNullBitMap = column.NullBitMapBuffers[0].ReadOnlySpan;`
	`247`	`+ var buffer = column.Buffers[0].ReadOnlySpan;`
	`248`	`+ var bitMap = column.NullBitMapBuffers[0].ReadOnlySpan;`
`265`	`249`	`long minRange = 0;`
`266`	`250`	`long maxRange = ReadOnlyDataFrameBuffer<T>.MaxCapacity;`
`267`	`251`	`long maxCapacity = maxRange;`
`@@ -274,17 +258,17 @@ protected T CalculateReduction(PrimitiveColumnContainer<T> column, Func<T, T, T>`
`274`	`258`	`if (row < minRange \|\| row >= maxRange)`
`275`	`259`	`{`
`276`	`260`	`int bufferIndex = (int)(row / maxCapacity);`
`277`		`- readOnlySpan = column.Buffers[bufferIndex].ReadOnlySpan;`
`278`		`- readOnlyNullBitMap = column.NullBitMapBuffers[bufferIndex].ReadOnlySpan;`
	`261`	`+ buffer = column.Buffers[bufferIndex].ReadOnlySpan;`
	`262`	`+ bitMap = column.NullBitMapBuffers[bufferIndex].ReadOnlySpan;`
`279`	`263`	`minRange = checked(bufferIndex * maxCapacity);`
`280`	`264`	`maxRange = checked((bufferIndex + 1) * maxCapacity);`
`281`	`265`	`}`
`282`	`266`	`row -= minRange;`
`283`	`267`
`284`		`- if (column.IsValid(readOnlyNullBitMap, (int)row))`
	`268`	`+ if (column.IsValid(bitMap, (int)row))`
`285`	`269`	`{`
`286`	`270`	`isValid = true;`
`287`		`- ret = readOnlySpan[(int)row];`
	`271`	`+ ret = buffer[(int)row];`
`288`	`272`	`}`
`289`	`273`	`}`
`290`	`274`
`@@ -294,14 +278,18 @@ protected T CalculateReduction(PrimitiveColumnContainer<T> column, Func<T, T, T>`
`294`	`278`	`if (row < minRange \|\| row >= maxRange)`
`295`	`279`	`{`
`296`	`280`	`int bufferIndex = (int)(row / maxCapacity);`
`297`		`- readOnlySpan = column.Buffers[bufferIndex].ReadOnlySpan;`
`298`		`- readOnlyNullBitMap = column.NullBitMapBuffers[bufferIndex].ReadOnlySpan;`
	`281`	`+ buffer = column.Buffers[bufferIndex].ReadOnlySpan;`
	`282`	`+ bitMap = column.NullBitMapBuffers[bufferIndex].ReadOnlySpan;`
`299`	`283`	`minRange = checked(bufferIndex * maxCapacity);`
`300`	`284`	`maxRange = checked((bufferIndex + 1) * maxCapacity);`
`301`	`285`	`}`
`302`	`286`	`row -= minRange;`
`303`	`287`
`304`		`- ret = checked(func(readOnlySpan[(int)row], ret));`
	`288`	`+ if (column.IsValid(bitMap, (int)row))`
	`289`	`+ {`
	`290`	`+ ret = checked(func(ret, buffer[(int)row]));`
	`291`	`+ }`
	`292`	`+`
`305`	`293`	`}`
`306`	`294`
`307`	`295`	`return ret;`