From 362448463c293de76877fba75ffc32b874c3ff5e Mon Sep 17 00:00:00 2001 From: Prashanth Govindarajan Date: Wed, 17 Apr 2019 14:17:28 -0700 Subject: [PATCH 1/8] Dataframe Infracture, Indexing and Basic BinaryOps --- corefxlab.sln | 34 +- src/Microsoft.Data/BaseDataFrameColumn.cs | 25 + src/Microsoft.Data/DataFrame.cs | 92 + .../DataFrameBinaryOperations.cs | 584 +++ .../DataFrameBinaryOperations.tt | 68 + src/Microsoft.Data/DataFrameBuffer.cs | 108 + .../DataFrameColumnArithmeticTemplate.cs | 1 + ...ataFrameColumnArithmeticTemplate.ttinclude | 228 + src/Microsoft.Data/DataFrameTable.cs | 133 + src/Microsoft.Data/Microsoft.Data.csproj | 51 + .../PrimitiveDataFrameColumn.cs | 69 + .../PrimitiveDataFrameColumnArithmetic.cs | 4138 +++++++++++++++++ .../PrimitiveDataFrameColumnArithmetic.tt | 83 + ...taFrameColumnContainer.BinaryOperations.cs | 162 + ...taFrameColumnContainer.BinaryOperations.tt | 43 + .../PrimitiveDataFrameColumnContainer.cs | 160 + tests/Microsoft.Data.Tests/DataFrameTests.cs | 127 + .../Microsoft.Data.Tests.csproj | 17 + 18 files changed, 6121 insertions(+), 2 deletions(-) create mode 100644 src/Microsoft.Data/BaseDataFrameColumn.cs create mode 100644 src/Microsoft.Data/DataFrame.cs create mode 100644 src/Microsoft.Data/DataFrameBinaryOperations.cs create mode 100644 src/Microsoft.Data/DataFrameBinaryOperations.tt create mode 100644 src/Microsoft.Data/DataFrameBuffer.cs create mode 100644 src/Microsoft.Data/DataFrameColumnArithmeticTemplate.cs create mode 100644 src/Microsoft.Data/DataFrameColumnArithmeticTemplate.ttinclude create mode 100644 src/Microsoft.Data/DataFrameTable.cs create mode 100644 src/Microsoft.Data/Microsoft.Data.csproj create mode 100644 src/Microsoft.Data/PrimitiveDataFrameColumn.cs create mode 100644 src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.cs create mode 100644 src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.tt create mode 100644 src/Microsoft.Data/PrimitiveDataFrameColumnContainer.BinaryOperations.cs create mode 100644 src/Microsoft.Data/PrimitiveDataFrameColumnContainer.BinaryOperations.tt create mode 100644 src/Microsoft.Data/PrimitiveDataFrameColumnContainer.cs create mode 100644 tests/Microsoft.Data.Tests/DataFrameTests.cs create mode 100644 tests/Microsoft.Data.Tests/Microsoft.Data.Tests.csproj diff --git a/corefxlab.sln b/corefxlab.sln index 1436517046d..1269f891525 100644 --- a/corefxlab.sln +++ b/corefxlab.sln @@ -1,6 +1,6 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio Version 16 -VisualStudioVersion = 16.0.28803.156 +# Visual Studio 15 +VisualStudioVersion = 15.0.28307.329 MinimumVisualStudioVersion = 10.0.40219.1 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{5E7EB061-B9BC-4DA2-B5E5-859AA7C67695}" ProjectSection(SolutionItems) = preProject @@ -110,6 +110,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Numerics.Experimenta EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Numerics.Experimental.Tests", "tests\System.Numerics.Experimental.Tests\System.Numerics.Experimental.Tests.csproj", "{6411FD4E-0CDF-4478-9192-4411DC932314}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Data", "src\Microsoft.Data\Microsoft.Data.csproj", "{AD22AAD4-FCB0-4DB4-BC38-AB6ACD153899}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Data.Tests", "tests\Microsoft.Data.Tests\Microsoft.Data.Tests.csproj", "{485FC567-4AEC-4335-B767-283173F64C42}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -696,6 +700,30 @@ Global {6411FD4E-0CDF-4478-9192-4411DC932314}.Release|x64.Build.0 = Release|Any CPU {6411FD4E-0CDF-4478-9192-4411DC932314}.Release|x86.ActiveCfg = Release|Any CPU {6411FD4E-0CDF-4478-9192-4411DC932314}.Release|x86.Build.0 = Release|Any CPU + {AD22AAD4-FCB0-4DB4-BC38-AB6ACD153899}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {AD22AAD4-FCB0-4DB4-BC38-AB6ACD153899}.Debug|Any CPU.Build.0 = Debug|Any CPU + {AD22AAD4-FCB0-4DB4-BC38-AB6ACD153899}.Debug|x64.ActiveCfg = Debug|Any CPU + {AD22AAD4-FCB0-4DB4-BC38-AB6ACD153899}.Debug|x64.Build.0 = Debug|Any CPU + {AD22AAD4-FCB0-4DB4-BC38-AB6ACD153899}.Debug|x86.ActiveCfg = Debug|Any CPU + {AD22AAD4-FCB0-4DB4-BC38-AB6ACD153899}.Debug|x86.Build.0 = Debug|Any CPU + {AD22AAD4-FCB0-4DB4-BC38-AB6ACD153899}.Release|Any CPU.ActiveCfg = Release|Any CPU + {AD22AAD4-FCB0-4DB4-BC38-AB6ACD153899}.Release|Any CPU.Build.0 = Release|Any CPU + {AD22AAD4-FCB0-4DB4-BC38-AB6ACD153899}.Release|x64.ActiveCfg = Release|Any CPU + {AD22AAD4-FCB0-4DB4-BC38-AB6ACD153899}.Release|x64.Build.0 = Release|Any CPU + {AD22AAD4-FCB0-4DB4-BC38-AB6ACD153899}.Release|x86.ActiveCfg = Release|Any CPU + {AD22AAD4-FCB0-4DB4-BC38-AB6ACD153899}.Release|x86.Build.0 = Release|Any CPU + {485FC567-4AEC-4335-B767-283173F64C42}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {485FC567-4AEC-4335-B767-283173F64C42}.Debug|Any CPU.Build.0 = Debug|Any CPU + {485FC567-4AEC-4335-B767-283173F64C42}.Debug|x64.ActiveCfg = Debug|Any CPU + {485FC567-4AEC-4335-B767-283173F64C42}.Debug|x64.Build.0 = Debug|Any CPU + {485FC567-4AEC-4335-B767-283173F64C42}.Debug|x86.ActiveCfg = Debug|Any CPU + {485FC567-4AEC-4335-B767-283173F64C42}.Debug|x86.Build.0 = Debug|Any CPU + {485FC567-4AEC-4335-B767-283173F64C42}.Release|Any CPU.ActiveCfg = Release|Any CPU + {485FC567-4AEC-4335-B767-283173F64C42}.Release|Any CPU.Build.0 = Release|Any CPU + {485FC567-4AEC-4335-B767-283173F64C42}.Release|x64.ActiveCfg = Release|Any CPU + {485FC567-4AEC-4335-B767-283173F64C42}.Release|x64.Build.0 = Release|Any CPU + {485FC567-4AEC-4335-B767-283173F64C42}.Release|x86.ActiveCfg = Release|Any CPU + {485FC567-4AEC-4335-B767-283173F64C42}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -749,6 +777,8 @@ Global {544D4C8C-B5C6-4C3C-9763-E4CB6AF9A90C} = {3079E458-D0E6-4F99-8CAB-80011D35C7DA} {CB424147-4ACB-4C35-AB24-8BD27D6AB1B9} = {4B000021-5278-4F2A-B734-DE49F55D4024} {6411FD4E-0CDF-4478-9192-4411DC932314} = {3079E458-D0E6-4F99-8CAB-80011D35C7DA} + {AD22AAD4-FCB0-4DB4-BC38-AB6ACD153899} = {4B000021-5278-4F2A-B734-DE49F55D4024} + {485FC567-4AEC-4335-B767-283173F64C42} = {3079E458-D0E6-4F99-8CAB-80011D35C7DA} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {9DD4022C-A010-4A9B-BCC5-171566D4CB17} diff --git a/src/Microsoft.Data/BaseDataFrameColumn.cs b/src/Microsoft.Data/BaseDataFrameColumn.cs new file mode 100644 index 00000000000..5280c561f16 --- /dev/null +++ b/src/Microsoft.Data/BaseDataFrameColumn.cs @@ -0,0 +1,25 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Collections.Generic; +using System.Text; + +namespace Microsoft.Data +{ + public abstract class BaseDataFrameColumn + { + public BaseDataFrameColumn(string name, long length = 0) + { + Length = length; + Name = name; + } + public long Length { get; protected set; } + public long NullCount { get; protected set; } + public string Name; + + public virtual object this[long rowIndex] { get { throw new NotImplementedException(); } set { throw new NotImplementedException(); } } + public virtual object this[long startIndex, int length] { get { throw new NotImplementedException(); } } + } +} diff --git a/src/Microsoft.Data/DataFrame.cs b/src/Microsoft.Data/DataFrame.cs new file mode 100644 index 00000000000..82aa93002dc --- /dev/null +++ b/src/Microsoft.Data/DataFrame.cs @@ -0,0 +1,92 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Collections.Generic; + +namespace Microsoft.Data +{ + /// + /// A DataFrame + /// + public partial class DataFrame + { + internal DataFrameTable _table; + public DataFrame() + { + _table = new DataFrameTable(); + } + + public long RowCount => _table.RowCount; + public int ColumnCount => _table.ColumnCount; + public IList Columns() + { + var ret = new List(); + for (int ii = 0; ii < ColumnCount; ii++) + { + ret.Add(_table.Column(ii).Name); + } + return ret; + } + public BaseDataFrameColumn Column(int index) => _table.Column(index); + public void InsertColumn(int columnIndex, BaseDataFrameColumn column) => _table.InsertColumn(columnIndex, column); + public void SetColumn(int columnIndex, BaseDataFrameColumn column) => _table.SetColumn(columnIndex, column); + public void RemoveColumn(int columnIndex) => _table.RemoveColumn(columnIndex); + public void RemoveColumn(string columnName) => _table.RemoveColumn(columnName); + + public object this[long rowIndex, int columnIndex] + { + get + { + return _table.Column(columnIndex)[rowIndex]; + } + set + { + _table.Column(columnIndex)[rowIndex] = value; + } + } + + #region Operators + public IList this[long rowIndex] + { + get + { + return _table.GetRow(rowIndex); + } + //TODO?: set? + } + + public object this[string columnName] + { + get + { + int columnIndex = _table.GetColumnIndex(columnName); + if (columnIndex == -1) throw new ArgumentException($"{columnName} does not exist"); + return _table.Column(columnIndex); //[0, (int)Math.Min(_table.NumRows, Int32.MaxValue)]; + } + } + + public IList> Head(int numberOfRows) + { + var ret = new List>(); + for (int ii = 0; ii < numberOfRows; ii++) + { + ret.Add(this[ii]); + } + return ret; + } + + public IList> Tail(int numberOfRows) + { + var ret = new List>(); + for (long ii = RowCount - numberOfRows; ii < RowCount; ii++) + { + ret.Add(this[ii]); + } + return ret; + } + // TODO: Add strongly typed versions of these APIs + #endregion + } +} diff --git a/src/Microsoft.Data/DataFrameBinaryOperations.cs b/src/Microsoft.Data/DataFrameBinaryOperations.cs new file mode 100644 index 00000000000..c8cd096ef91 --- /dev/null +++ b/src/Microsoft.Data/DataFrameBinaryOperations.cs @@ -0,0 +1,584 @@ + +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Collections.Generic; + +namespace Microsoft.Data +{ + public partial class DataFrame + { + #region Binary Operations + + public DataFrame Add(IReadOnlyList values) + where T : struct + { + if (values.Count != ColumnCount) + { + throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); + } + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + var newColumn = column.Clone(); + newColumn._columnContainer.Add(values[ii]); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame Add(T value) + where T : struct + { + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + var newColumn = column.Clone(); + newColumn._columnContainer.Add(value); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame Subtract(IReadOnlyList values) + where T : struct + { + if (values.Count != ColumnCount) + { + throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); + } + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + var newColumn = column.Clone(); + newColumn._columnContainer.Subtract(values[ii]); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame Subtract(T value) + where T : struct + { + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + var newColumn = column.Clone(); + newColumn._columnContainer.Subtract(value); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame Multiply(IReadOnlyList values) + where T : struct + { + if (values.Count != ColumnCount) + { + throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); + } + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + var newColumn = column.Clone(); + newColumn._columnContainer.Multiply(values[ii]); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame Multiply(T value) + where T : struct + { + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + var newColumn = column.Clone(); + newColumn._columnContainer.Multiply(value); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame Divide(IReadOnlyList values) + where T : struct + { + if (values.Count != ColumnCount) + { + throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); + } + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + var newColumn = column.Clone(); + newColumn._columnContainer.Divide(values[ii]); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame Divide(T value) + where T : struct + { + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + var newColumn = column.Clone(); + newColumn._columnContainer.Divide(value); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame Modulo(IReadOnlyList values) + where T : struct + { + if (values.Count != ColumnCount) + { + throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); + } + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + var newColumn = column.Clone(); + newColumn._columnContainer.Modulo(values[ii]); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame Modulo(T value) + where T : struct + { + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + var newColumn = column.Clone(); + newColumn._columnContainer.Modulo(value); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame And(IReadOnlyList values) + where T : struct + { + if (values.Count != ColumnCount) + { + throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); + } + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + var newColumn = column.Clone(); + newColumn._columnContainer.And(values[ii]); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame And(T value) + where T : struct + { + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + var newColumn = column.Clone(); + newColumn._columnContainer.And(value); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame Or(IReadOnlyList values) + where T : struct + { + if (values.Count != ColumnCount) + { + throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); + } + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + var newColumn = column.Clone(); + newColumn._columnContainer.Or(values[ii]); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame Or(T value) + where T : struct + { + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + var newColumn = column.Clone(); + newColumn._columnContainer.Or(value); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame Xor(IReadOnlyList values) + where T : struct + { + if (values.Count != ColumnCount) + { + throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); + } + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + var newColumn = column.Clone(); + newColumn._columnContainer.Xor(values[ii]); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame Xor(T value) + where T : struct + { + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + var newColumn = column.Clone(); + newColumn._columnContainer.Xor(value); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame LeftShift(int value) + where T : struct + { + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + var newColumn = column.Clone(); + newColumn._columnContainer.LeftShift(value); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame RightShift(int value) + where T : struct + { + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + var newColumn = column.Clone(); + newColumn._columnContainer.RightShift(value); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame Equals(IReadOnlyList values) + where T : struct + { + if (values.Count != ColumnCount) + { + throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); + } + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); + column._columnContainer.Equals(values[ii], newColumn._columnContainer); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame Equals(T value) + where T : struct + { + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); + column._columnContainer.Equals(value, newColumn._columnContainer); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame NotEquals(IReadOnlyList values) + where T : struct + { + if (values.Count != ColumnCount) + { + throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); + } + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); + column._columnContainer.NotEquals(values[ii], newColumn._columnContainer); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame NotEquals(T value) + where T : struct + { + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); + column._columnContainer.NotEquals(value, newColumn._columnContainer); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame GreaterThanOrEqual(IReadOnlyList values) + where T : struct + { + if (values.Count != ColumnCount) + { + throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); + } + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); + column._columnContainer.GreaterThanOrEqual(values[ii], newColumn._columnContainer); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame GreaterThanOrEqual(T value) + where T : struct + { + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); + column._columnContainer.GreaterThanOrEqual(value, newColumn._columnContainer); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame LessThanOrEqual(IReadOnlyList values) + where T : struct + { + if (values.Count != ColumnCount) + { + throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); + } + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); + column._columnContainer.LessThanOrEqual(values[ii], newColumn._columnContainer); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame LessThanOrEqual(T value) + where T : struct + { + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); + column._columnContainer.LessThanOrEqual(value, newColumn._columnContainer); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame GreaterThan(IReadOnlyList values) + where T : struct + { + if (values.Count != ColumnCount) + { + throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); + } + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); + column._columnContainer.GreaterThan(values[ii], newColumn._columnContainer); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame GreaterThan(T value) + where T : struct + { + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); + column._columnContainer.GreaterThan(value, newColumn._columnContainer); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame LessThan(IReadOnlyList values) + where T : struct + { + if (values.Count != ColumnCount) + { + throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); + } + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); + column._columnContainer.LessThan(values[ii], newColumn._columnContainer); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + public DataFrame LessThan(T value) + where T : struct + { + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { + PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); + column._columnContainer.LessThan(value, newColumn._columnContainer); + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + + + #endregion + } +} diff --git a/src/Microsoft.Data/DataFrameBinaryOperations.tt b/src/Microsoft.Data/DataFrameBinaryOperations.tt new file mode 100644 index 00000000000..87c138346bd --- /dev/null +++ b/src/Microsoft.Data/DataFrameBinaryOperations.tt @@ -0,0 +1,68 @@ +<#@ template debug="false" hostspecific="false" language="C#" #> +<#@ assembly name="System.Core" #> +<#@ import namespace="System.Linq" #> +<#@ import namespace="System.Text" #> +<#@ import namespace="System.Collections.Generic" #> +<#@ output extension=".cs" #> +<#@ include file="DataFrameColumnArithmeticTemplate.ttinclude" #> +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Collections.Generic; + +namespace Microsoft.Data +{ + public partial class DataFrame + { + #region Binary Operations + +<# foreach (MethodConfiguration method in methodConfiguration) { #> +<# if (method.MethodType == MethodType.BinaryScalar || method.MethodType == MethodType.ComparisonScalar) {#> + public DataFrame <#=method.MethodName#>(T value) +<# } else if (method.MethodType == MethodType.BinaryInt) { #> + public DataFrame <#=method.MethodName#>(int value) +<# } else { #> + public DataFrame <#=method.MethodName#>(IReadOnlyList values) +<# } #> + where T : struct + { +<# if (method.MethodType == MethodType.BinaryScalar || method.MethodType == MethodType.ComparisonScalar || method.MethodType == MethodType.BinaryInt) {#> +<# } else { #> + if (values.Count != ColumnCount) + { + throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); + } +<# } #> + var newDataFrame = new DataFrame(); + for (int ii = 0; ii < ColumnCount; ii++) + { + PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + if (column != null) + { +<# if (method.MethodType == MethodType.ComparisonScalar || method.MethodType == MethodType.Comparison) { #> + PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); +<# if (method.MethodType == MethodType.ComparisonScalar) { #> + column._columnContainer.<#=method.MethodName#>(value, newColumn._columnContainer); +<# } else { #> + column._columnContainer.<#=method.MethodName#>(values[ii], newColumn._columnContainer); +<# } #> +<# } else if (method.MethodType == MethodType.BinaryScalar || method.MethodType == MethodType.BinaryInt) { #> + var newColumn = column.Clone(); + newColumn._columnContainer.<#=method.MethodName#>(value); +<# } else { #> + var newColumn = column.Clone(); + newColumn._columnContainer.<#=method.MethodName#>(values[ii]); +<# } #> + newDataFrame.InsertColumn(ii, newColumn); + } + } + return newDataFrame; + } + +<# } #> + + #endregion + } +} diff --git a/src/Microsoft.Data/DataFrameBuffer.cs b/src/Microsoft.Data/DataFrameBuffer.cs new file mode 100644 index 00000000000..db8d09932b4 --- /dev/null +++ b/src/Microsoft.Data/DataFrameBuffer.cs @@ -0,0 +1,108 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Collections.Generic; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Microsoft.Data +{ + public class DataFrameBuffer + where T : struct + { + // TODO: Change this to Memory + public Memory Memory { get; private set; } + private readonly int _size; + + private int Capacity => Memory.Length / _size; + + public int MaxCapacity => Int32.MaxValue / _size; + + public Span Span + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get => MemoryMarshal.Cast(Memory.Span); + } + + public int Length { get; internal set; } + + public DataFrameBuffer(int numberOfValues = 8) + { + _size = Unsafe.SizeOf(); + if ((long)numberOfValues * _size > MaxCapacity) + { + throw new ArgumentException($"{numberOfValues} exceeds buffer capacity", nameof(numberOfValues)); + } + Memory = new byte[numberOfValues * _size]; + Length = 0; + } + + public void Append(T value) + { + if (Length == MaxCapacity) + { + throw new ArgumentException("Current buffer is full", nameof(value)); + } + EnsureCapacity(1); + Span[Length] = value; + if (Length < MaxCapacity) ++Length; + } + // TODO: Implement Append(Range of values)? + public void EnsureCapacity(int numberOfValues) + { + long newLength = Length + (long)numberOfValues; + if (newLength > MaxCapacity) + { + throw new ArgumentException("Current buffer is full", nameof(numberOfValues)); + } + + if (newLength > Capacity) + { + var newCapacity = Math.Max(newLength * _size, Memory.Length * 2); + var memory = new Memory(new byte[newCapacity]); + Memory.CopyTo(memory); + Memory = memory; + } + } + + internal T this[int index] + { + get + { + if (index > Length) throw new ArgumentOutOfRangeException(nameof(index)); + return Span[index]; + } + set + { + if (index > Length) throw new ArgumentOutOfRangeException(nameof(index)); + Span[index] = value; + } + } + + internal bool this[int startIndex, int length, IList returnList] + { + get + { + if (startIndex > Length) throw new ArgumentOutOfRangeException(nameof(startIndex)); + long endIndex = Math.Min(Length, startIndex + length); + for (int ii = startIndex; ii < endIndex; ii++) + { + returnList.Add(Span[ii]); + } + return true; + } + } + public override string ToString() + { + string ret = ""; + Span span = Span; + for (int ii = 0; ii < Length; ii++) + { + ret += span[ii] + " "; + } + return ret; + } + } +} diff --git a/src/Microsoft.Data/DataFrameColumnArithmeticTemplate.cs b/src/Microsoft.Data/DataFrameColumnArithmeticTemplate.cs new file mode 100644 index 00000000000..5f282702bb0 --- /dev/null +++ b/src/Microsoft.Data/DataFrameColumnArithmeticTemplate.cs @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/src/Microsoft.Data/DataFrameColumnArithmeticTemplate.ttinclude b/src/Microsoft.Data/DataFrameColumnArithmeticTemplate.ttinclude new file mode 100644 index 00000000000..8a1fdca4e0b --- /dev/null +++ b/src/Microsoft.Data/DataFrameColumnArithmeticTemplate.ttinclude @@ -0,0 +1,228 @@ +<#@ template debug="false" hostspecific="false" language="C#" #> +<#@ assembly name="System.Core" #> +<#@ import namespace="System.Linq" #> +<#@ import namespace="System.Text" #> +<#@ import namespace="System.Collections.Generic" #> +<#+ + public class TypeConfiguration + { + public TypeConfiguration(string typeName, string classPrefix = null, string oneLiteral = "1", string zeroLiteral = "0", bool supportsNumeric = true, bool supportsBitwise = true, IEnumerable unsupportedMethods = null) + { + TypeName = typeName; + ClassPrefix = classPrefix ?? char.ToUpper(typeName[0]) + typeName.Substring(1); + OneLiteral = oneLiteral; + ZeroLiteral = zeroLiteral; + SupportsNumeric = supportsNumeric; + SupportsBitwise = supportsBitwise; + UnsupportedMethods = new HashSet(unsupportedMethods ?? Enumerable.Empty()); + } + + public string TypeName { get; } + public string ClassPrefix { get; } + public string OneLiteral { get; } + public string ZeroLiteral { get; } + + public bool SupportsNumeric { get; } + public bool SupportsBitwise { get; } + public ISet UnsupportedMethods { get; } + } + + public string GenerateIfStatementHeader(TypeConfiguration type) + { + string keyword = (type == typeConfiguration[0]) ? "if" : "else if"; + return $"{keyword} (typeof(T) == typeof({type.TypeName}))"; + } + + public TypeConfiguration[] typeConfiguration = new [] + { + new TypeConfiguration("bool", oneLiteral:"true", zeroLiteral:"false", supportsNumeric: false, unsupportedMethods: new[] {"LeftShift", "RightShift"}), + new TypeConfiguration("byte"), + new TypeConfiguration("char", oneLiteral:"(char)1", zeroLiteral:"(char)0"), + new TypeConfiguration("decimal", supportsBitwise: false), + new TypeConfiguration("double", oneLiteral:"1.0", supportsBitwise: false), + new TypeConfiguration("float", oneLiteral:"1.0f", supportsBitwise: false), + new TypeConfiguration("int"), + new TypeConfiguration("long"), + new TypeConfiguration("sbyte", classPrefix:"SByte"), + new TypeConfiguration("short"), + new TypeConfiguration("uint", classPrefix:"UInt", unsupportedMethods: new[] {"UnaryMinus"}), + new TypeConfiguration("ulong", classPrefix:"ULong", unsupportedMethods: new[] {"UnaryMinus"}), + new TypeConfiguration("ushort", classPrefix:"UShort", unsupportedMethods: new[] {"UnaryMinus"}) + }; + + public enum MethodType + { + Unary, + UnaryInPlace, + BinaryScalar, + BinaryInt, + Binary, + Comparison, + ComparisonScalar, + Contraction + } + + public MethodConfiguration[] methodConfiguration = new [] + { + new MethodConfiguration("Add", MethodType.Binary, "+", isNumeric:true), + new MethodConfiguration("Add", MethodType.BinaryScalar, "+", isNumeric:true), + new MethodConfiguration("Subtract", MethodType.Binary, "-", isNumeric:true), + new MethodConfiguration("Subtract", MethodType.BinaryScalar, "-", isNumeric:true), + new MethodConfiguration("Multiply", MethodType.Binary, "*", isNumeric:true), // element-wise product, not matrix product + new MethodConfiguration("Multiply", MethodType.BinaryScalar, "*", isNumeric:true), + new MethodConfiguration("Divide", MethodType.Binary, "/", isNumeric:true), + new MethodConfiguration("Divide", MethodType.BinaryScalar, "/", isNumeric:true), + new MethodConfiguration("Modulo", MethodType.Binary, "%", isNumeric:true), + new MethodConfiguration("Modulo", MethodType.BinaryScalar, "%", isNumeric:true), + new MethodConfiguration("And", MethodType.Binary, "&", isBitwise: true), + new MethodConfiguration("And", MethodType.BinaryScalar, "&", isBitwise: true), + new MethodConfiguration("Or", MethodType.Binary, "|", isBitwise: true), + new MethodConfiguration("Or", MethodType.BinaryScalar, "|", isBitwise: true), + new MethodConfiguration("Xor", MethodType.Binary, "^", isBitwise: true), + new MethodConfiguration("Xor", MethodType.BinaryScalar, "^", isBitwise: true), + new MethodConfiguration("LeftShift", MethodType.BinaryInt, "<<", isBitwise: true), + new MethodConfiguration("RightShift", MethodType.BinaryInt, ">>", isBitwise: true), + + new MethodConfiguration("Equals", MethodType.Comparison, "=="), + new MethodConfiguration("Equals", MethodType.ComparisonScalar, "=="), + new MethodConfiguration("NotEquals", MethodType.Comparison, "!="), + new MethodConfiguration("NotEquals", MethodType.ComparisonScalar, "!="), + new MethodConfiguration("GreaterThanOrEqual", MethodType.Comparison, ">=", isNumeric:true), + new MethodConfiguration("GreaterThanOrEqual", MethodType.ComparisonScalar, ">=", isNumeric:true), + new MethodConfiguration("LessThanOrEqual", MethodType.Comparison, "<=", isNumeric:true), + new MethodConfiguration("LessThanOrEqual", MethodType.ComparisonScalar, "<=", isNumeric:true), + new MethodConfiguration("GreaterThan", MethodType.Comparison, ">", isNumeric:true), + new MethodConfiguration("GreaterThan", MethodType.ComparisonScalar, ">", isNumeric:true), + new MethodConfiguration("LessThan", MethodType.Comparison, "<", isNumeric:true), + new MethodConfiguration("LessThan", MethodType.ComparisonScalar, "<", isNumeric:true), + }; + + + public class MethodConfiguration + { + public MethodConfiguration(string methodName, MethodType methodType, string op = null, bool isNumeric = false, bool isBitwise = false) + { + MethodName = methodName; + MethodType = methodType; + Operator = op; + IsNumeric = isNumeric; + IsBitwise = isBitwise; + } + + public string ResultName => "result"; + + public string Op1Name + { + get + { + switch (MethodType) + { + case MethodType.Unary: + case MethodType.UnaryInPlace: + case MethodType.BinaryScalar: + case MethodType.BinaryInt: + case MethodType.ComparisonScalar: + return "column"; + case MethodType.Binary: + case MethodType.Comparison: + case MethodType.Contraction: + return "left"; + default: + throw new ArgumentException(); + }; + } + } + + public string Op2Name + { + get + { + switch (MethodType) + { + case MethodType.BinaryScalar: + case MethodType.ComparisonScalar: + return "scalar"; + case MethodType.BinaryInt: + return "value"; + case MethodType.Binary: + case MethodType.Comparison: + case MethodType.Contraction: + return "right"; + case MethodType.Unary: + case MethodType.UnaryInPlace: + default: + throw new ArgumentException(); + }; + } + } + + public string MethodName { get; } + public MethodType MethodType { get; } + public string Operator { get; } + + public string GetMethodSignature(string columnType, string genericType) + { + var arguments = GetMethodArguments(columnType, genericType); + return $"void {MethodName}({arguments})"; + } + + public string GetSingleArgumentMethodSignature(string columnType, string genericType) + { + var arguments = GetSingleParameterMethodArguments(columnType, genericType); + return $"PrimitiveDataFrameColumnContainer {MethodName}({arguments})"; + } + + public string GetMethodArguments(string dataFrameType, string genericType) + { + switch (MethodType) + { + case MethodType.Unary: + case MethodType.UnaryInPlace: + return $"{dataFrameType}<{genericType}> {Op1Name}"; + case MethodType.BinaryScalar: + return $"{dataFrameType}<{genericType}> {Op1Name}, {genericType} {Op2Name}"; + case MethodType.ComparisonScalar: + return $"{dataFrameType}<{genericType}> {Op1Name}, {genericType} {Op2Name}, {dataFrameType} ret"; + case MethodType.BinaryInt: + return $"{dataFrameType}<{genericType}> {Op1Name}, int {Op2Name}"; + case MethodType.Binary: + return $"{dataFrameType}<{genericType}> {Op1Name}, {dataFrameType}<{genericType}> {Op2Name}"; + case MethodType.Comparison: + return $"{dataFrameType}<{genericType}> {Op1Name}, {dataFrameType}<{genericType}> {Op2Name}, {dataFrameType} ret"; + case MethodType.Contraction: + return $"{dataFrameType}<{genericType}> {Op1Name}, {dataFrameType}<{genericType}> {Op2Name}, int[] leftAxes, int[] rightAxes"; + default: + throw new ArgumentException(); + } + } + + public string GetSingleParameterMethodArguments(string dataFrameType, string genericType) + { + switch (MethodType) + { + case MethodType.Unary: + case MethodType.UnaryInPlace: + throw new ArgumentException(); + return $"{dataFrameType}<{genericType}> {Op1Name}"; + case MethodType.BinaryScalar: + return $"{genericType} {Op2Name}"; + case MethodType.ComparisonScalar: + return $"{genericType} {Op2Name}, {dataFrameType} ret"; + case MethodType.BinaryInt: + return $"int {Op2Name}"; + case MethodType.Binary: + return $"{dataFrameType}<{genericType}> {Op2Name}"; + case MethodType.Comparison: + return $"{dataFrameType}<{genericType}> {Op2Name}, {dataFrameType} ret"; + case MethodType.Contraction: + throw new ArgumentException(); + return $"{dataFrameType}<{genericType}> {Op1Name}, {dataFrameType}<{genericType}> {Op2Name}, int[] leftAxes, int[] rightAxes"; + default: + throw new ArgumentException(); + } + } + + public bool IsNumeric { get; } + public bool IsBitwise { get; } + } +#> diff --git a/src/Microsoft.Data/DataFrameTable.cs b/src/Microsoft.Data/DataFrameTable.cs new file mode 100644 index 00000000000..6b4b36b212f --- /dev/null +++ b/src/Microsoft.Data/DataFrameTable.cs @@ -0,0 +1,133 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Collections.Generic; + +namespace Microsoft.Data +{ + /// + /// A DataFrameTable is just a container that holds a number of DataFrameColumns. It mainly acts as a convenient store to allow DataFrame to implement its algorithms + /// + internal class DataFrameTable + { + private IList _columns; + + private List _columnNames = new List(); + private Dictionary _columnNameToIndexDictionary = new Dictionary(); + + public long RowCount { get; private set; } = 0; + public int ColumnCount { get; private set; } = 0; + public DataFrameTable() + { + _columns = new List(); + } + + public DataFrameTable(IList columns) + { + columns = columns ?? throw new ArgumentNullException(nameof(columns)); + _columns = columns; + ColumnCount = columns.Count; + if (columns.Count > 0) + { + RowCount = columns[0].Length; + int cc = 0; + foreach (var column in columns) + { + _columnNames.Add(column.Name); + _columnNameToIndexDictionary.Add(column.Name, cc++); + } + } + } + + public DataFrameTable(BaseDataFrameColumn column) : this(new List { column }) { } + public BaseDataFrameColumn Column(int columnIndex) => _columns[columnIndex]; + public IList GetRow(long rowIndex) + { + var ret = new List(); + for (int ii = 0; ii < ColumnCount; ii++) + { + ret.Add(Column(ii)[rowIndex]); + } + return ret; + } + + public void InsertColumn(int columnIndex, IEnumerable column, string columnName) + where T : struct + { + column = column ?? throw new ArgumentNullException(nameof(column)); + if (columnIndex < 0 || columnIndex > _columns.Count) + { + throw new ArgumentException($"Invalid columnIndex {columnIndex} passed into Table.AddColumn"); + } + BaseDataFrameColumn newColumn = new PrimitiveDataFrameColumn(columnName, column); + InsertColumn(columnIndex, newColumn); + } + public void InsertColumn(int columnIndex, BaseDataFrameColumn column) + { + column = column ?? throw new ArgumentNullException(nameof(column)); + if (columnIndex < 0 || columnIndex > _columns.Count) + { + throw new ArgumentException($"Invalid columnIndex {columnIndex} passed into Table.AddColumn"); + } + if (RowCount > 0 && column.Length != RowCount) + { + throw new ArgumentException($"Column's length {column.Length} must match Table's length {RowCount}"); + } + if (_columnNameToIndexDictionary.ContainsKey(column.Name)) + { + throw new ArgumentException($"Table already contains a column called {column.Name}"); + } + RowCount = column.Length; + _columnNames.Insert(columnIndex, column.Name); + _columnNameToIndexDictionary[column.Name] = columnIndex; + _columns.Insert(columnIndex, column); + ColumnCount++; + } + public void SetColumn(int columnIndex, BaseDataFrameColumn column) + { + column = column ?? throw new ArgumentNullException(nameof(column)); + if (columnIndex < 0 || columnIndex >= ColumnCount) + { + throw new ArgumentException($"Invalid columnIndex {columnIndex} passed in to Table.SetColumn"); + } + if (RowCount > 0 && column.Length != RowCount) + { + throw new ArgumentException($"Column's length {column.Length} must match table's length {RowCount}"); + } + if (_columnNameToIndexDictionary.ContainsKey(column.Name)) + { + throw new ArgumentException($"Table already contains a column called {column.Name}"); + } + _columnNameToIndexDictionary.Remove(_columnNames[columnIndex]); + _columnNames[columnIndex] = column.Name; + _columnNameToIndexDictionary[column.Name] = columnIndex; + _columns[columnIndex] = column; + } + public void RemoveColumn(int columnIndex) + { + _columnNameToIndexDictionary.Remove(_columnNames[columnIndex]); + _columnNames.RemoveAt(columnIndex); + _columns.RemoveAt(columnIndex); + ColumnCount--; + } + public void RemoveColumn(string columnName) + { + int columnIndex = GetColumnIndex(columnName); + if (columnIndex != -1) + { + RemoveColumn(columnIndex); + } + } + + public int GetColumnIndex(string columnName) + { + if (_columnNameToIndexDictionary.TryGetValue(columnName, out int columnIndex) ) + { + return columnIndex; + } + return -1; + } + } +} diff --git a/src/Microsoft.Data/Microsoft.Data.csproj b/src/Microsoft.Data/Microsoft.Data.csproj new file mode 100644 index 00000000000..8c77f8c470b --- /dev/null +++ b/src/Microsoft.Data/Microsoft.Data.csproj @@ -0,0 +1,51 @@ + + + + netcoreapp2.2 + + + + + + + + + + + + TextTemplatingFileGenerator + DataFrameBinaryOperations.cs + + + TextTemplatingFileGenerator + PrimitiveDataFrameColumnArithmetic.cs + + + TextTemplatingFileGenerator + PrimitiveDataFrameColumnContainer.BinaryOperations.cs + + + + + + + + + + True + True + DataFrameBinaryOperations.tt + + + True + True + PrimitiveDataFrameColumnArithmetic.tt + + + True + True + PrimitiveDataFrameColumnContainer.BinaryOperations.tt + + + + diff --git a/src/Microsoft.Data/PrimitiveDataFrameColumn.cs b/src/Microsoft.Data/PrimitiveDataFrameColumn.cs new file mode 100644 index 00000000000..3f7432a94cf --- /dev/null +++ b/src/Microsoft.Data/PrimitiveDataFrameColumn.cs @@ -0,0 +1,69 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Collections.Generic; + +namespace Microsoft.Data +{ + public class PrimitiveDataFrameColumn : BaseDataFrameColumn + where T : struct + { + internal PrimitiveDataFrameColumnContainer _columnContainer; + public Type DataType = typeof(T); + internal PrimitiveDataFrameColumn(string name, PrimitiveDataFrameColumnContainer column) : base(name, column.Length) + { + _columnContainer = column; + } + public PrimitiveDataFrameColumn(string name, IEnumerable values) : base(name) + { + _columnContainer = new PrimitiveDataFrameColumnContainer(values); + Length = _columnContainer.Length; + } + public PrimitiveDataFrameColumn(string name, bool isNullable = true) : base(name) + { + _columnContainer = new PrimitiveDataFrameColumnContainer(); + } + + public override object this[long startIndex, int length] { + get + { + if (startIndex > Length ) + { + throw new ArgumentException($"Indexer arguments exceed Length {Length} of the Column"); + } + return _columnContainer[startIndex, length]; + } + } + + // This method involves boxing + public override object this[long rowIndex] + { + get + { + return _columnContainer[rowIndex]; + } + set + { + _columnContainer[rowIndex] = (T)value; + } + } + public void Add(T value) => _columnContainer.Add(value); + public override string ToString() + { + return $"{Name}: {_columnContainer.ToString()}"; + } + public PrimitiveDataFrameColumn Clone() + { + PrimitiveDataFrameColumnContainer newColumnContainer = _columnContainer.Clone(); + return new PrimitiveDataFrameColumn(Name, newColumnContainer); + } + + internal PrimitiveDataFrameColumn CreateBoolColumnForCompareOps() + { + PrimitiveDataFrameColumnContainer newColumnContainer = _columnContainer.CreateBoolContainerForCompareOps(); + return new PrimitiveDataFrameColumn(Name, newColumnContainer); + } + } +} diff --git a/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.cs b/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.cs new file mode 100644 index 00000000000..0968e723f12 --- /dev/null +++ b/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.cs @@ -0,0 +1,4138 @@ + + +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; + +namespace Microsoft.Data +{ + internal interface IPrimitiveDataFrameColumnArithmetic + where T : struct + { + void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right); + void Add(PrimitiveDataFrameColumnContainer column, T scalar); + void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right); + void Subtract(PrimitiveDataFrameColumnContainer column, T scalar); + void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right); + void Multiply(PrimitiveDataFrameColumnContainer column, T scalar); + void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right); + void Divide(PrimitiveDataFrameColumnContainer column, T scalar); + void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right); + void Modulo(PrimitiveDataFrameColumnContainer column, T scalar); + void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right); + void And(PrimitiveDataFrameColumnContainer column, T scalar); + void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right); + void Or(PrimitiveDataFrameColumnContainer column, T scalar); + void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right); + void Xor(PrimitiveDataFrameColumnContainer column, T scalar); + void LeftShift(PrimitiveDataFrameColumnContainer column, int value); + void RightShift(PrimitiveDataFrameColumnContainer column, int value); + void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret); + void Equals(PrimitiveDataFrameColumnContainer column, T scalar, PrimitiveDataFrameColumnContainer ret); + void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret); + void NotEquals(PrimitiveDataFrameColumnContainer column, T scalar, PrimitiveDataFrameColumnContainer ret); + void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret); + void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, T scalar, PrimitiveDataFrameColumnContainer ret); + void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret); + void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, T scalar, PrimitiveDataFrameColumnContainer ret); + void GreaterThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret); + void GreaterThan(PrimitiveDataFrameColumnContainer column, T scalar, PrimitiveDataFrameColumnContainer ret); + void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret); + void LessThan(PrimitiveDataFrameColumnContainer column, T scalar, PrimitiveDataFrameColumnContainer ret); + } + + internal static class PrimitiveDataFrameColumnArithmetic + where T : struct + { + public static IPrimitiveDataFrameColumnArithmetic Instance => PrimitiveDataFrameColumnArithmetic.GetArithmetic(); + } + + internal static class PrimitiveDataFrameColumnArithmetic + { + public static IPrimitiveDataFrameColumnArithmetic GetArithmetic() + where T : struct + { + if (typeof(T) == typeof(bool)) + { + return (IPrimitiveDataFrameColumnArithmetic)new BoolArithmetic(); + } + else if (typeof(T) == typeof(byte)) + { + return (IPrimitiveDataFrameColumnArithmetic)new ByteArithmetic(); + } + else if (typeof(T) == typeof(char)) + { + return (IPrimitiveDataFrameColumnArithmetic)new CharArithmetic(); + } + else if (typeof(T) == typeof(decimal)) + { + return (IPrimitiveDataFrameColumnArithmetic)new DecimalArithmetic(); + } + else if (typeof(T) == typeof(double)) + { + return (IPrimitiveDataFrameColumnArithmetic)new DoubleArithmetic(); + } + else if (typeof(T) == typeof(float)) + { + return (IPrimitiveDataFrameColumnArithmetic)new FloatArithmetic(); + } + else if (typeof(T) == typeof(int)) + { + return (IPrimitiveDataFrameColumnArithmetic)new IntArithmetic(); + } + else if (typeof(T) == typeof(long)) + { + return (IPrimitiveDataFrameColumnArithmetic)new LongArithmetic(); + } + else if (typeof(T) == typeof(sbyte)) + { + return (IPrimitiveDataFrameColumnArithmetic)new SByteArithmetic(); + } + else if (typeof(T) == typeof(short)) + { + return (IPrimitiveDataFrameColumnArithmetic)new ShortArithmetic(); + } + else if (typeof(T) == typeof(uint)) + { + return (IPrimitiveDataFrameColumnArithmetic)new UIntArithmetic(); + } + else if (typeof(T) == typeof(ulong)) + { + return (IPrimitiveDataFrameColumnArithmetic)new ULongArithmetic(); + } + else if (typeof(T) == typeof(ushort)) + { + return (IPrimitiveDataFrameColumnArithmetic)new UShortArithmetic(); + } + return null; + } + } + + internal class BoolArithmetic : IPrimitiveDataFrameColumnArithmetic + { + public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + throw new NotSupportedException(); + } + public void Add(PrimitiveDataFrameColumnContainer column, bool scalar) + { + throw new NotSupportedException(); + } + public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + throw new NotSupportedException(); + } + public void Subtract(PrimitiveDataFrameColumnContainer column, bool scalar) + { + throw new NotSupportedException(); + } + public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + throw new NotSupportedException(); + } + public void Multiply(PrimitiveDataFrameColumnContainer column, bool scalar) + { + throw new NotSupportedException(); + } + public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + throw new NotSupportedException(); + } + public void Divide(PrimitiveDataFrameColumnContainer column, bool scalar) + { + throw new NotSupportedException(); + } + public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + throw new NotSupportedException(); + } + public void Modulo(PrimitiveDataFrameColumnContainer column, bool scalar) + { + throw new NotSupportedException(); + } + public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (bool)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + } + } + } + public void And(PrimitiveDataFrameColumnContainer column, bool scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (bool)(buffer.Span[ii] & scalar); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (bool)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer column, bool scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (bool)(buffer.Span[ii] | scalar); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (bool)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer column, bool scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (bool)(buffer.Span[ii] ^ scalar); + } + } + } + public void LeftShift(PrimitiveDataFrameColumnContainer column, int value) + { + throw new NotSupportedException(); + } + public void RightShift(PrimitiveDataFrameColumnContainer column, int value) + { + throw new NotSupportedException(); + } + public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer column, bool scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == scalar); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer column, bool scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != scalar); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + throw new NotSupportedException(); + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, bool scalar, PrimitiveDataFrameColumnContainer ret) + { + throw new NotSupportedException(); + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + throw new NotSupportedException(); + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, bool scalar, PrimitiveDataFrameColumnContainer ret) + { + throw new NotSupportedException(); + } + public void GreaterThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + throw new NotSupportedException(); + } + public void GreaterThan(PrimitiveDataFrameColumnContainer column, bool scalar, PrimitiveDataFrameColumnContainer ret) + { + throw new NotSupportedException(); + } + public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + throw new NotSupportedException(); + } + public void LessThan(PrimitiveDataFrameColumnContainer column, bool scalar, PrimitiveDataFrameColumnContainer ret) + { + throw new NotSupportedException(); + } + } + internal class ByteArithmetic : IPrimitiveDataFrameColumnArithmetic + { + public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (byte)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + } + } + } + public void Add(PrimitiveDataFrameColumnContainer column, byte scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (byte)(buffer.Span[ii] + scalar); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (byte)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer column, byte scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (byte)(buffer.Span[ii] - scalar); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (byte)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer column, byte scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (byte)(buffer.Span[ii] * scalar); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (byte)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer column, byte scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (byte)(buffer.Span[ii] / scalar); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (byte)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer column, byte scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (byte)(buffer.Span[ii] % scalar); + } + } + } + public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (byte)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + } + } + } + public void And(PrimitiveDataFrameColumnContainer column, byte scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (byte)(buffer.Span[ii] & scalar); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (byte)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer column, byte scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (byte)(buffer.Span[ii] | scalar); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (byte)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer column, byte scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (byte)(buffer.Span[ii] ^ scalar); + } + } + } + public void LeftShift(PrimitiveDataFrameColumnContainer column, int value) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (byte)(buffer.Span[ii] << value); + } + } + } + public void RightShift(PrimitiveDataFrameColumnContainer column, int value) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (byte)(buffer.Span[ii] >> value); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer column, byte scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == scalar); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer column, byte scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != scalar); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, byte scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= scalar); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, byte scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= scalar); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer column, byte scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > scalar); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer column, byte scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < scalar); + } + } + } + } + internal class CharArithmetic : IPrimitiveDataFrameColumnArithmetic + { + public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (char)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + } + } + } + public void Add(PrimitiveDataFrameColumnContainer column, char scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (char)(buffer.Span[ii] + scalar); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (char)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer column, char scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (char)(buffer.Span[ii] - scalar); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (char)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer column, char scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (char)(buffer.Span[ii] * scalar); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (char)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer column, char scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (char)(buffer.Span[ii] / scalar); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (char)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer column, char scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (char)(buffer.Span[ii] % scalar); + } + } + } + public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (char)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + } + } + } + public void And(PrimitiveDataFrameColumnContainer column, char scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (char)(buffer.Span[ii] & scalar); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (char)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer column, char scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (char)(buffer.Span[ii] | scalar); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (char)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer column, char scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (char)(buffer.Span[ii] ^ scalar); + } + } + } + public void LeftShift(PrimitiveDataFrameColumnContainer column, int value) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (char)(buffer.Span[ii] << value); + } + } + } + public void RightShift(PrimitiveDataFrameColumnContainer column, int value) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (char)(buffer.Span[ii] >> value); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer column, char scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == scalar); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer column, char scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != scalar); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, char scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= scalar); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, char scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= scalar); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer column, char scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > scalar); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer column, char scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < scalar); + } + } + } + } + internal class DecimalArithmetic : IPrimitiveDataFrameColumnArithmetic + { + public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (decimal)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + } + } + } + public void Add(PrimitiveDataFrameColumnContainer column, decimal scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (decimal)(buffer.Span[ii] + scalar); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (decimal)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer column, decimal scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (decimal)(buffer.Span[ii] - scalar); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (decimal)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer column, decimal scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (decimal)(buffer.Span[ii] * scalar); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (decimal)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer column, decimal scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (decimal)(buffer.Span[ii] / scalar); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (decimal)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer column, decimal scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (decimal)(buffer.Span[ii] % scalar); + } + } + } + public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + throw new NotSupportedException(); + } + public void And(PrimitiveDataFrameColumnContainer column, decimal scalar) + { + throw new NotSupportedException(); + } + public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + throw new NotSupportedException(); + } + public void Or(PrimitiveDataFrameColumnContainer column, decimal scalar) + { + throw new NotSupportedException(); + } + public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + throw new NotSupportedException(); + } + public void Xor(PrimitiveDataFrameColumnContainer column, decimal scalar) + { + throw new NotSupportedException(); + } + public void LeftShift(PrimitiveDataFrameColumnContainer column, int value) + { + throw new NotSupportedException(); + } + public void RightShift(PrimitiveDataFrameColumnContainer column, int value) + { + throw new NotSupportedException(); + } + public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer column, decimal scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == scalar); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer column, decimal scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != scalar); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, decimal scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= scalar); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, decimal scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= scalar); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer column, decimal scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > scalar); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer column, decimal scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < scalar); + } + } + } + } + internal class DoubleArithmetic : IPrimitiveDataFrameColumnArithmetic + { + public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (double)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + } + } + } + public void Add(PrimitiveDataFrameColumnContainer column, double scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (double)(buffer.Span[ii] + scalar); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (double)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer column, double scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (double)(buffer.Span[ii] - scalar); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (double)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer column, double scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (double)(buffer.Span[ii] * scalar); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (double)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer column, double scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (double)(buffer.Span[ii] / scalar); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (double)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer column, double scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (double)(buffer.Span[ii] % scalar); + } + } + } + public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + throw new NotSupportedException(); + } + public void And(PrimitiveDataFrameColumnContainer column, double scalar) + { + throw new NotSupportedException(); + } + public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + throw new NotSupportedException(); + } + public void Or(PrimitiveDataFrameColumnContainer column, double scalar) + { + throw new NotSupportedException(); + } + public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + throw new NotSupportedException(); + } + public void Xor(PrimitiveDataFrameColumnContainer column, double scalar) + { + throw new NotSupportedException(); + } + public void LeftShift(PrimitiveDataFrameColumnContainer column, int value) + { + throw new NotSupportedException(); + } + public void RightShift(PrimitiveDataFrameColumnContainer column, int value) + { + throw new NotSupportedException(); + } + public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer column, double scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == scalar); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer column, double scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != scalar); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, double scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= scalar); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, double scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= scalar); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer column, double scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > scalar); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer column, double scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < scalar); + } + } + } + } + internal class FloatArithmetic : IPrimitiveDataFrameColumnArithmetic + { + public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (float)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + } + } + } + public void Add(PrimitiveDataFrameColumnContainer column, float scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (float)(buffer.Span[ii] + scalar); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (float)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer column, float scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (float)(buffer.Span[ii] - scalar); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (float)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer column, float scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (float)(buffer.Span[ii] * scalar); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (float)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer column, float scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (float)(buffer.Span[ii] / scalar); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (float)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer column, float scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (float)(buffer.Span[ii] % scalar); + } + } + } + public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + throw new NotSupportedException(); + } + public void And(PrimitiveDataFrameColumnContainer column, float scalar) + { + throw new NotSupportedException(); + } + public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + throw new NotSupportedException(); + } + public void Or(PrimitiveDataFrameColumnContainer column, float scalar) + { + throw new NotSupportedException(); + } + public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + throw new NotSupportedException(); + } + public void Xor(PrimitiveDataFrameColumnContainer column, float scalar) + { + throw new NotSupportedException(); + } + public void LeftShift(PrimitiveDataFrameColumnContainer column, int value) + { + throw new NotSupportedException(); + } + public void RightShift(PrimitiveDataFrameColumnContainer column, int value) + { + throw new NotSupportedException(); + } + public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer column, float scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == scalar); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer column, float scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != scalar); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, float scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= scalar); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, float scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= scalar); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer column, float scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > scalar); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer column, float scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < scalar); + } + } + } + } + internal class IntArithmetic : IPrimitiveDataFrameColumnArithmetic + { + public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (int)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + } + } + } + public void Add(PrimitiveDataFrameColumnContainer column, int scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (int)(buffer.Span[ii] + scalar); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (int)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer column, int scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (int)(buffer.Span[ii] - scalar); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (int)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer column, int scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (int)(buffer.Span[ii] * scalar); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (int)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer column, int scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (int)(buffer.Span[ii] / scalar); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (int)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer column, int scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (int)(buffer.Span[ii] % scalar); + } + } + } + public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (int)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + } + } + } + public void And(PrimitiveDataFrameColumnContainer column, int scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (int)(buffer.Span[ii] & scalar); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (int)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer column, int scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (int)(buffer.Span[ii] | scalar); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (int)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer column, int scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (int)(buffer.Span[ii] ^ scalar); + } + } + } + public void LeftShift(PrimitiveDataFrameColumnContainer column, int value) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (int)(buffer.Span[ii] << value); + } + } + } + public void RightShift(PrimitiveDataFrameColumnContainer column, int value) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (int)(buffer.Span[ii] >> value); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer column, int scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == scalar); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer column, int scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != scalar); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, int scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= scalar); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, int scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= scalar); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer column, int scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > scalar); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer column, int scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < scalar); + } + } + } + } + internal class LongArithmetic : IPrimitiveDataFrameColumnArithmetic + { + public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (long)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + } + } + } + public void Add(PrimitiveDataFrameColumnContainer column, long scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (long)(buffer.Span[ii] + scalar); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (long)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer column, long scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (long)(buffer.Span[ii] - scalar); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (long)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer column, long scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (long)(buffer.Span[ii] * scalar); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (long)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer column, long scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (long)(buffer.Span[ii] / scalar); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (long)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer column, long scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (long)(buffer.Span[ii] % scalar); + } + } + } + public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (long)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + } + } + } + public void And(PrimitiveDataFrameColumnContainer column, long scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (long)(buffer.Span[ii] & scalar); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (long)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer column, long scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (long)(buffer.Span[ii] | scalar); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (long)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer column, long scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (long)(buffer.Span[ii] ^ scalar); + } + } + } + public void LeftShift(PrimitiveDataFrameColumnContainer column, int value) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (long)(buffer.Span[ii] << value); + } + } + } + public void RightShift(PrimitiveDataFrameColumnContainer column, int value) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (long)(buffer.Span[ii] >> value); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer column, long scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == scalar); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer column, long scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != scalar); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, long scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= scalar); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, long scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= scalar); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer column, long scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > scalar); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer column, long scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < scalar); + } + } + } + } + internal class SByteArithmetic : IPrimitiveDataFrameColumnArithmetic + { + public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (sbyte)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + } + } + } + public void Add(PrimitiveDataFrameColumnContainer column, sbyte scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (sbyte)(buffer.Span[ii] + scalar); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (sbyte)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer column, sbyte scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (sbyte)(buffer.Span[ii] - scalar); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (sbyte)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer column, sbyte scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (sbyte)(buffer.Span[ii] * scalar); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (sbyte)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer column, sbyte scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (sbyte)(buffer.Span[ii] / scalar); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (sbyte)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer column, sbyte scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (sbyte)(buffer.Span[ii] % scalar); + } + } + } + public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (sbyte)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + } + } + } + public void And(PrimitiveDataFrameColumnContainer column, sbyte scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (sbyte)(buffer.Span[ii] & scalar); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (sbyte)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer column, sbyte scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (sbyte)(buffer.Span[ii] | scalar); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (sbyte)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer column, sbyte scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (sbyte)(buffer.Span[ii] ^ scalar); + } + } + } + public void LeftShift(PrimitiveDataFrameColumnContainer column, int value) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (sbyte)(buffer.Span[ii] << value); + } + } + } + public void RightShift(PrimitiveDataFrameColumnContainer column, int value) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (sbyte)(buffer.Span[ii] >> value); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer column, sbyte scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == scalar); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer column, sbyte scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != scalar); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, sbyte scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= scalar); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, sbyte scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= scalar); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer column, sbyte scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > scalar); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer column, sbyte scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < scalar); + } + } + } + } + internal class ShortArithmetic : IPrimitiveDataFrameColumnArithmetic + { + public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (short)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + } + } + } + public void Add(PrimitiveDataFrameColumnContainer column, short scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (short)(buffer.Span[ii] + scalar); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (short)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer column, short scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (short)(buffer.Span[ii] - scalar); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (short)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer column, short scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (short)(buffer.Span[ii] * scalar); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (short)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer column, short scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (short)(buffer.Span[ii] / scalar); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (short)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer column, short scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (short)(buffer.Span[ii] % scalar); + } + } + } + public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (short)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + } + } + } + public void And(PrimitiveDataFrameColumnContainer column, short scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (short)(buffer.Span[ii] & scalar); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (short)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer column, short scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (short)(buffer.Span[ii] | scalar); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (short)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer column, short scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (short)(buffer.Span[ii] ^ scalar); + } + } + } + public void LeftShift(PrimitiveDataFrameColumnContainer column, int value) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (short)(buffer.Span[ii] << value); + } + } + } + public void RightShift(PrimitiveDataFrameColumnContainer column, int value) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (short)(buffer.Span[ii] >> value); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer column, short scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == scalar); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer column, short scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != scalar); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, short scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= scalar); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, short scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= scalar); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer column, short scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > scalar); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer column, short scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < scalar); + } + } + } + } + internal class UIntArithmetic : IPrimitiveDataFrameColumnArithmetic + { + public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (uint)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + } + } + } + public void Add(PrimitiveDataFrameColumnContainer column, uint scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (uint)(buffer.Span[ii] + scalar); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (uint)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer column, uint scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (uint)(buffer.Span[ii] - scalar); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (uint)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer column, uint scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (uint)(buffer.Span[ii] * scalar); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (uint)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer column, uint scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (uint)(buffer.Span[ii] / scalar); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (uint)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer column, uint scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (uint)(buffer.Span[ii] % scalar); + } + } + } + public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (uint)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + } + } + } + public void And(PrimitiveDataFrameColumnContainer column, uint scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (uint)(buffer.Span[ii] & scalar); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (uint)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer column, uint scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (uint)(buffer.Span[ii] | scalar); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (uint)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer column, uint scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (uint)(buffer.Span[ii] ^ scalar); + } + } + } + public void LeftShift(PrimitiveDataFrameColumnContainer column, int value) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (uint)(buffer.Span[ii] << value); + } + } + } + public void RightShift(PrimitiveDataFrameColumnContainer column, int value) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (uint)(buffer.Span[ii] >> value); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer column, uint scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == scalar); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer column, uint scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != scalar); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, uint scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= scalar); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, uint scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= scalar); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer column, uint scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > scalar); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer column, uint scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < scalar); + } + } + } + } + internal class ULongArithmetic : IPrimitiveDataFrameColumnArithmetic + { + public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ulong)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + } + } + } + public void Add(PrimitiveDataFrameColumnContainer column, ulong scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ulong)(buffer.Span[ii] + scalar); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ulong)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer column, ulong scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ulong)(buffer.Span[ii] - scalar); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ulong)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer column, ulong scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ulong)(buffer.Span[ii] * scalar); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ulong)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer column, ulong scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ulong)(buffer.Span[ii] / scalar); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ulong)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer column, ulong scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ulong)(buffer.Span[ii] % scalar); + } + } + } + public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ulong)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + } + } + } + public void And(PrimitiveDataFrameColumnContainer column, ulong scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ulong)(buffer.Span[ii] & scalar); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ulong)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer column, ulong scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ulong)(buffer.Span[ii] | scalar); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ulong)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer column, ulong scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ulong)(buffer.Span[ii] ^ scalar); + } + } + } + public void LeftShift(PrimitiveDataFrameColumnContainer column, int value) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ulong)(buffer.Span[ii] << value); + } + } + } + public void RightShift(PrimitiveDataFrameColumnContainer column, int value) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ulong)(buffer.Span[ii] >> value); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer column, ulong scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == scalar); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer column, ulong scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != scalar); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, ulong scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= scalar); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, ulong scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= scalar); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer column, ulong scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > scalar); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer column, ulong scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < scalar); + } + } + } + } + internal class UShortArithmetic : IPrimitiveDataFrameColumnArithmetic + { + public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ushort)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + } + } + } + public void Add(PrimitiveDataFrameColumnContainer column, ushort scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ushort)(buffer.Span[ii] + scalar); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ushort)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + } + } + } + public void Subtract(PrimitiveDataFrameColumnContainer column, ushort scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ushort)(buffer.Span[ii] - scalar); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ushort)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + } + } + } + public void Multiply(PrimitiveDataFrameColumnContainer column, ushort scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ushort)(buffer.Span[ii] * scalar); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ushort)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + } + } + } + public void Divide(PrimitiveDataFrameColumnContainer column, ushort scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ushort)(buffer.Span[ii] / scalar); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ushort)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + } + } + } + public void Modulo(PrimitiveDataFrameColumnContainer column, ushort scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ushort)(buffer.Span[ii] % scalar); + } + } + } + public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ushort)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + } + } + } + public void And(PrimitiveDataFrameColumnContainer column, ushort scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ushort)(buffer.Span[ii] & scalar); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ushort)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + } + } + } + public void Or(PrimitiveDataFrameColumnContainer column, ushort scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ushort)(buffer.Span[ii] | scalar); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ushort)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + } + } + } + public void Xor(PrimitiveDataFrameColumnContainer column, ushort scalar) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ushort)(buffer.Span[ii] ^ scalar); + } + } + } + public void LeftShift(PrimitiveDataFrameColumnContainer column, int value) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ushort)(buffer.Span[ii] << value); + } + } + } + public void RightShift(PrimitiveDataFrameColumnContainer column, int value) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + buffer.Span[ii] = (ushort)(buffer.Span[ii] >> value); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + } + } + } + public void Equals(PrimitiveDataFrameColumnContainer column, ushort scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] == scalar); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + } + } + } + public void NotEquals(PrimitiveDataFrameColumnContainer column, ushort scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] != scalar); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, ushort scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] >= scalar); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + } + } + } + public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, ushort scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] <= scalar); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + } + } + } + public void GreaterThan(PrimitiveDataFrameColumnContainer column, ushort scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] > scalar); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < left.Buffers.Count; bb++) + { + var buffer = left.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + } + } + } + public void LessThan(PrimitiveDataFrameColumnContainer column, ushort scalar, PrimitiveDataFrameColumnContainer ret) + { + for (int bb = 0 ; bb < column.Buffers.Count; bb++) + { + var buffer = column.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { + ret[ii] = (buffer.Span[ii] < scalar); + } + } + } + } + + + + +} diff --git a/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.tt b/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.tt new file mode 100644 index 00000000000..02ea3dc3d8d --- /dev/null +++ b/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.tt @@ -0,0 +1,83 @@ +<#@ template debug="false" hostspecific="false" language="C#" #> +<#@ assembly name="System" #> +<#@ assembly name="System.Core" #> +<#@ import namespace="System.Linq" #> +<#@ import namespace="System.Text" #> +<#@ import namespace="System.Collections.Generic" #> +<#@ output extension=".cs" #> +<#@ include file="DataFrameColumnArithmeticTemplate.ttinclude" #> + +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; + +namespace Microsoft.Data +{ + internal interface IPrimitiveDataFrameColumnArithmetic + where T : struct + { +<# foreach (MethodConfiguration method in methodConfiguration) { #> + <#= method.GetMethodSignature("PrimitiveDataFrameColumnContainer", "T")#>; +<# } #> + } + + internal static class PrimitiveDataFrameColumnArithmetic + where T : struct + { + public static IPrimitiveDataFrameColumnArithmetic Instance => PrimitiveDataFrameColumnArithmetic.GetArithmetic(); + } + + internal static class PrimitiveDataFrameColumnArithmetic + { + public static IPrimitiveDataFrameColumnArithmetic GetArithmetic() + where T : struct + { +<# foreach (TypeConfiguration type in typeConfiguration) { #> + <#=GenerateIfStatementHeader(type)#> + { + return (IPrimitiveDataFrameColumnArithmetic)new <#=type.ClassPrefix#>Arithmetic(); + } +<# } #> + return null; + } + } + +<# foreach (TypeConfiguration type in typeConfiguration) { #> + internal class <#=type.ClassPrefix#>Arithmetic : IPrimitiveDataFrameColumnArithmetic<<#=type.TypeName#>> + { +<# foreach (MethodConfiguration method in methodConfiguration) { #> + public <#= method.GetMethodSignature("PrimitiveDataFrameColumnContainer", type.TypeName) #> + { +<# if ((method.IsNumeric && !type.SupportsNumeric) || (method.IsBitwise && !type.SupportsBitwise) || (type.UnsupportedMethods.Contains(method.MethodName))) { #> + throw new NotSupportedException(); +<# } else if (method.Operator != null) { #> + for (int bb = 0 ; bb < <#= method.Op1Name #>.Buffers.Count; bb++) + { + var buffer = <#= method.Op1Name #>.Buffers[bb]; + for (int ii = 0; ii < buffer.Length; ii++) + { +<# if (method.MethodType == MethodType.BinaryScalar || method.MethodType == MethodType.BinaryInt) { #> + buffer.Span[ii] = (<#=type.TypeName#>)(buffer.Span[ii] <#= method.Operator #> <#= method.Op2Name #>); +<# } else if (method.MethodType == MethodType.Binary) { #> + buffer.Span[ii] = (<#=type.TypeName#>)(buffer.Span[ii] <#= method.Operator #> <#= method.Op2Name #>.Buffers[bb].Span[ii]); +<# } else if (method.MethodType == MethodType.Comparison) { #> + ret[ii] = (buffer.Span[ii] <#= method.Operator #> <#= method.Op2Name #>.Buffers[bb].Span[ii]); +<# } else if (method.MethodType == MethodType.ComparisonScalar) { #> + ret[ii] = (buffer.Span[ii] <#= method.Operator #> <#= method.Op2Name #>); +<# } else {#> + throw new NotImplementedException(); +<# } #> + } + } +<# } #> + } +<# } #> + } +<# } #> + + + + +} diff --git a/src/Microsoft.Data/PrimitiveDataFrameColumnContainer.BinaryOperations.cs b/src/Microsoft.Data/PrimitiveDataFrameColumnContainer.BinaryOperations.cs new file mode 100644 index 00000000000..de3249b29de --- /dev/null +++ b/src/Microsoft.Data/PrimitiveDataFrameColumnContainer.BinaryOperations.cs @@ -0,0 +1,162 @@ + +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +namespace Microsoft.Data +{ + internal partial class PrimitiveDataFrameColumnContainer + where T : struct + { + public PrimitiveDataFrameColumnContainer Add(PrimitiveDataFrameColumnContainer right) + { + PrimitiveDataFrameColumnArithmetic.Instance.Add(this, right); + return this; + } + public PrimitiveDataFrameColumnContainer Add(T scalar) + { + PrimitiveDataFrameColumnArithmetic.Instance.Add(this, scalar); + return this; + } + public PrimitiveDataFrameColumnContainer Subtract(PrimitiveDataFrameColumnContainer right) + { + PrimitiveDataFrameColumnArithmetic.Instance.Subtract(this, right); + return this; + } + public PrimitiveDataFrameColumnContainer Subtract(T scalar) + { + PrimitiveDataFrameColumnArithmetic.Instance.Subtract(this, scalar); + return this; + } + public PrimitiveDataFrameColumnContainer Multiply(PrimitiveDataFrameColumnContainer right) + { + PrimitiveDataFrameColumnArithmetic.Instance.Multiply(this, right); + return this; + } + public PrimitiveDataFrameColumnContainer Multiply(T scalar) + { + PrimitiveDataFrameColumnArithmetic.Instance.Multiply(this, scalar); + return this; + } + public PrimitiveDataFrameColumnContainer Divide(PrimitiveDataFrameColumnContainer right) + { + PrimitiveDataFrameColumnArithmetic.Instance.Divide(this, right); + return this; + } + public PrimitiveDataFrameColumnContainer Divide(T scalar) + { + PrimitiveDataFrameColumnArithmetic.Instance.Divide(this, scalar); + return this; + } + public PrimitiveDataFrameColumnContainer Modulo(PrimitiveDataFrameColumnContainer right) + { + PrimitiveDataFrameColumnArithmetic.Instance.Modulo(this, right); + return this; + } + public PrimitiveDataFrameColumnContainer Modulo(T scalar) + { + PrimitiveDataFrameColumnArithmetic.Instance.Modulo(this, scalar); + return this; + } + public PrimitiveDataFrameColumnContainer And(PrimitiveDataFrameColumnContainer right) + { + PrimitiveDataFrameColumnArithmetic.Instance.And(this, right); + return this; + } + public PrimitiveDataFrameColumnContainer And(T scalar) + { + PrimitiveDataFrameColumnArithmetic.Instance.And(this, scalar); + return this; + } + public PrimitiveDataFrameColumnContainer Or(PrimitiveDataFrameColumnContainer right) + { + PrimitiveDataFrameColumnArithmetic.Instance.Or(this, right); + return this; + } + public PrimitiveDataFrameColumnContainer Or(T scalar) + { + PrimitiveDataFrameColumnArithmetic.Instance.Or(this, scalar); + return this; + } + public PrimitiveDataFrameColumnContainer Xor(PrimitiveDataFrameColumnContainer right) + { + PrimitiveDataFrameColumnArithmetic.Instance.Xor(this, right); + return this; + } + public PrimitiveDataFrameColumnContainer Xor(T scalar) + { + PrimitiveDataFrameColumnArithmetic.Instance.Xor(this, scalar); + return this; + } + public PrimitiveDataFrameColumnContainer LeftShift(int value) + { + PrimitiveDataFrameColumnArithmetic.Instance.LeftShift(this, value); + return this; + } + public PrimitiveDataFrameColumnContainer RightShift(int value) + { + PrimitiveDataFrameColumnArithmetic.Instance.RightShift(this, value); + return this; + } + public PrimitiveDataFrameColumnContainer Equals(PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + PrimitiveDataFrameColumnArithmetic.Instance.Equals(this, right, ret); + return this; + } + public PrimitiveDataFrameColumnContainer Equals(T scalar, PrimitiveDataFrameColumnContainer ret) + { + PrimitiveDataFrameColumnArithmetic.Instance.Equals(this, scalar, ret); + return this; + } + public PrimitiveDataFrameColumnContainer NotEquals(PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + PrimitiveDataFrameColumnArithmetic.Instance.NotEquals(this, right, ret); + return this; + } + public PrimitiveDataFrameColumnContainer NotEquals(T scalar, PrimitiveDataFrameColumnContainer ret) + { + PrimitiveDataFrameColumnArithmetic.Instance.NotEquals(this, scalar, ret); + return this; + } + public PrimitiveDataFrameColumnContainer GreaterThanOrEqual(PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + PrimitiveDataFrameColumnArithmetic.Instance.GreaterThanOrEqual(this, right, ret); + return this; + } + public PrimitiveDataFrameColumnContainer GreaterThanOrEqual(T scalar, PrimitiveDataFrameColumnContainer ret) + { + PrimitiveDataFrameColumnArithmetic.Instance.GreaterThanOrEqual(this, scalar, ret); + return this; + } + public PrimitiveDataFrameColumnContainer LessThanOrEqual(PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + PrimitiveDataFrameColumnArithmetic.Instance.LessThanOrEqual(this, right, ret); + return this; + } + public PrimitiveDataFrameColumnContainer LessThanOrEqual(T scalar, PrimitiveDataFrameColumnContainer ret) + { + PrimitiveDataFrameColumnArithmetic.Instance.LessThanOrEqual(this, scalar, ret); + return this; + } + public PrimitiveDataFrameColumnContainer GreaterThan(PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + PrimitiveDataFrameColumnArithmetic.Instance.GreaterThan(this, right, ret); + return this; + } + public PrimitiveDataFrameColumnContainer GreaterThan(T scalar, PrimitiveDataFrameColumnContainer ret) + { + PrimitiveDataFrameColumnArithmetic.Instance.GreaterThan(this, scalar, ret); + return this; + } + public PrimitiveDataFrameColumnContainer LessThan(PrimitiveDataFrameColumnContainer right, PrimitiveDataFrameColumnContainer ret) + { + PrimitiveDataFrameColumnArithmetic.Instance.LessThan(this, right, ret); + return this; + } + public PrimitiveDataFrameColumnContainer LessThan(T scalar, PrimitiveDataFrameColumnContainer ret) + { + PrimitiveDataFrameColumnArithmetic.Instance.LessThan(this, scalar, ret); + return this; + } + } +} diff --git a/src/Microsoft.Data/PrimitiveDataFrameColumnContainer.BinaryOperations.tt b/src/Microsoft.Data/PrimitiveDataFrameColumnContainer.BinaryOperations.tt new file mode 100644 index 00000000000..d9771196cba --- /dev/null +++ b/src/Microsoft.Data/PrimitiveDataFrameColumnContainer.BinaryOperations.tt @@ -0,0 +1,43 @@ +<#@ template debug="false" hostspecific="false" language="C#" #> +<#@ assembly name="System.Core" #> +<#@ import namespace="System.Linq" #> +<#@ import namespace="System.Text" #> +<#@ import namespace="System.Collections.Generic" #> +<#@ output extension=".cs" #> +<#@ include file="DataFrameColumnArithmeticTemplate.ttinclude" #> +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +namespace Microsoft.Data +{ + internal partial class PrimitiveDataFrameColumnContainer + where T : struct + { +<# foreach (MethodConfiguration method in methodConfiguration) { #> +<# if (method.MethodType == MethodType.Comparison || method.MethodType == MethodType.ComparisonScalar) { #> + public <#= method.GetSingleArgumentMethodSignature("PrimitiveDataFrameColumnContainer", "T") #> + { +<# if (method.MethodType == MethodType.ComparisonScalar ) { #> + PrimitiveDataFrameColumnArithmetic.Instance.<#=method.MethodName#>(this, scalar, ret); +<# } else { #> + PrimitiveDataFrameColumnArithmetic.Instance.<#=method.MethodName#>(this, right, ret); +<# } #> + return this; + } +<# } else { #> + public <#= method.GetSingleArgumentMethodSignature("PrimitiveDataFrameColumnContainer", "T")#> + { +<# if (method.MethodType == MethodType.BinaryScalar) { #> + PrimitiveDataFrameColumnArithmetic.Instance.<#=method.MethodName#>(this, scalar); +<# } else if (method.MethodType == MethodType.BinaryInt) { #> + PrimitiveDataFrameColumnArithmetic.Instance.<#=method.MethodName#>(this, value); +<# } else { #> + PrimitiveDataFrameColumnArithmetic.Instance.<#=method.MethodName#>(this, right); +<# } #> + return this; + } +<# } #> +<# } #> + } +} diff --git a/src/Microsoft.Data/PrimitiveDataFrameColumnContainer.cs b/src/Microsoft.Data/PrimitiveDataFrameColumnContainer.cs new file mode 100644 index 00000000000..d539ac101e3 --- /dev/null +++ b/src/Microsoft.Data/PrimitiveDataFrameColumnContainer.cs @@ -0,0 +1,160 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Collections.Generic; +using System.Text; + +namespace Microsoft.Data +{ + /// + /// PrimitiveDataFrameColumnContainer is just a store for the column data. APIs that want to change the data must be defined in PrimitiveDataFrameColumn + /// + /// + internal partial class PrimitiveDataFrameColumnContainer + where T : struct + { + public IList> Buffers = new List>(); + public PrimitiveDataFrameColumnContainer(T[] values) + { + values = values ?? throw new ArgumentNullException(nameof(values)); + long length = values.LongLength; + DataFrameBuffer curBuffer; + if (Buffers.Count == 0) + { + curBuffer = new DataFrameBuffer(); + Buffers.Add(curBuffer); + } + else + { + curBuffer = Buffers[Buffers.Count - 1]; + } + for (long i = 0; i < length; i++) + { + if (curBuffer.Length == curBuffer.MaxCapacity) + { + curBuffer = new DataFrameBuffer(); + Buffers.Add(curBuffer); + } + curBuffer.Append(values[i]); + Length++; + } + } + public PrimitiveDataFrameColumnContainer(IEnumerable values) + { + values = values ?? throw new ArgumentNullException(nameof(values)); + if (Buffers.Count == 0) + { + Buffers.Add(new DataFrameBuffer()); + } + var curBuffer = Buffers[Buffers.Count - 1]; + foreach (var value in values) + { + if (curBuffer.Length == curBuffer.MaxCapacity) + { + curBuffer = new DataFrameBuffer(); + Buffers.Add(curBuffer); + } + curBuffer.Append(value); + Length++; + } + } + public PrimitiveDataFrameColumnContainer() { } + public long Length; + //TODO: + public long NullCount => throw new NotImplementedException(); + private int GetArrayContainingRowIndex(ref long rowIndex) + { + if (rowIndex > Length) + { + throw new ArgumentException($"Index {rowIndex} cannot be greater than the Column's Length {Length}"); + } + int curArrayIndex = 0; + int numBuffers = Buffers.Count; + while (curArrayIndex < numBuffers && rowIndex > Buffers[curArrayIndex].Length) + { + rowIndex -= Buffers[curArrayIndex].Length; + curArrayIndex++; + } + return curArrayIndex; + } + + public IList this[long startIndex, int length] + { + get + { + var ret = new List(length); + long endIndex = startIndex + length; + int arrayIndex = GetArrayContainingRowIndex(ref startIndex); + bool temp = Buffers[arrayIndex][(int)startIndex, length, ret]; + while (ret.Count < length) + { + arrayIndex++; + temp = Buffers[arrayIndex][0, length - ret.Count, ret]; + } + return ret; + } + } + public T this[long rowIndex] + { + get + { + int arrayIndex = GetArrayContainingRowIndex(ref rowIndex); + return Buffers[arrayIndex][(int)rowIndex]; + } + set + { + int arrayIndex = GetArrayContainingRowIndex(ref rowIndex); + Buffers[arrayIndex][(int)rowIndex] = value; + } + } + + public override string ToString() + { + StringBuilder sb = new StringBuilder(""); + foreach (var buffer in Buffers) + { + sb.Append(buffer.ToString()); + // Can this run out of memory? Just being safe here + if (sb.Length > 1000) + { + sb.Append("..."); + break; + } + } + return sb.ToString(); + } + public PrimitiveDataFrameColumnContainer Clone() + { + var ret = new PrimitiveDataFrameColumnContainer(); + foreach (DataFrameBuffer buffer in Buffers) + { + DataFrameBuffer newBuffer = new DataFrameBuffer(); + ret.Buffers.Add(newBuffer); + var span = buffer.Span; + ret.Length += buffer.Length; + for (int ii = 0; ii < buffer.Length; ii++) + { + newBuffer.Append(span[ii]); + } + } + return ret; + } + + internal PrimitiveDataFrameColumnContainer CreateBoolContainerForCompareOps() + { + var ret = new PrimitiveDataFrameColumnContainer(); + foreach (var buffer in Buffers) + { + DataFrameBuffer newBuffer = new DataFrameBuffer(); + ret.Buffers.Add(newBuffer); + newBuffer.EnsureCapacity(buffer.Length); + newBuffer.Span.Fill(false); + newBuffer.Length = buffer.Length; + ret.Length += buffer.Length; + } + return ret; + } + } +} diff --git a/tests/Microsoft.Data.Tests/DataFrameTests.cs b/tests/Microsoft.Data.Tests/DataFrameTests.cs new file mode 100644 index 00000000000..0d536e09bcc --- /dev/null +++ b/tests/Microsoft.Data.Tests/DataFrameTests.cs @@ -0,0 +1,127 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Linq; +using System.Collections.Generic; +using Microsoft.Data; +using Xunit; + +namespace Microsoft.Data.Tests +{ + public class DataFrameTests + { + static public DataFrame MakeTestTableWithTwoColumns(int length) + { + BaseDataFrameColumn dataFrameColumn1 = new PrimitiveDataFrameColumn("Int1", Enumerable.Range(0, length).Select(x => x)); + BaseDataFrameColumn dataFrameColumn2 = new PrimitiveDataFrameColumn("Int2", Enumerable.Range(10, length).Select(x => x)); + Data.DataFrame dataFrame = new Data.DataFrame(); + dataFrame.InsertColumn(0, dataFrameColumn1); + dataFrame.InsertColumn(1, dataFrameColumn2); + return dataFrame; + } + [Fact] + public void TestIndexer() + { + Data.DataFrame dataFrame = MakeTestTableWithTwoColumns(length: 10); + var foo = dataFrame[0, 0]; + Assert.Equal(0, dataFrame[0, 0]); + Assert.Equal(11, dataFrame[1, 1]); + Assert.Equal(2, dataFrame.Columns().Count); + Assert.Equal("Int1", dataFrame.Columns()[0]); + + var headList = dataFrame.Head(5); + Assert.Equal(14, (int)headList[4][1]); + + var tailList = dataFrame.Tail(5); + Assert.Equal(19, (int)tailList[4][1]); + + dataFrame[2, 1] = 1000; + Assert.Equal(1000, dataFrame[2, 1]); + + var row = dataFrame[4]; + Assert.Equal(14, (int)row[1]); + + var column = dataFrame["Int2"] as PrimitiveDataFrameColumn; + Assert.Equal(1000, (int)column[2]); + + Assert.Throws(() => dataFrame["Int5"]); + } + + [Fact] + public void ColumnAndTableCreationTest() + { + BaseDataFrameColumn intColumn = new PrimitiveDataFrameColumn("IntColumn", Enumerable.Range(0, 10).Select(x => x)); + BaseDataFrameColumn floatColumn = new PrimitiveDataFrameColumn("FloatColumn", Enumerable.Range(0, 10).Select(x => (float)x)); + DataFrame dataFrame = new DataFrame(); + dataFrame.InsertColumn(0, intColumn); + dataFrame.InsertColumn(1, floatColumn); + Assert.Equal(10, dataFrame.RowCount); + Assert.Equal(2, dataFrame.ColumnCount); + Assert.Equal(10, dataFrame.Column(0).Length); + Assert.Equal("IntColumn", dataFrame.Column(0).Name); + Assert.Equal(10, dataFrame.Column(1).Length); + Assert.Equal("FloatColumn", dataFrame.Column(1).Name); + + BaseDataFrameColumn bigColumn = new PrimitiveDataFrameColumn("BigColumn", Enumerable.Range(0, 11).Select(x => (float)x)); + BaseDataFrameColumn repeatedName = new PrimitiveDataFrameColumn("FloatColumn", Enumerable.Range(0, 10).Select(x => (float)x)); + Assert.Throws( () => dataFrame.InsertColumn(2, bigColumn)); + Assert.Throws( () => dataFrame.InsertColumn(2, repeatedName)); + Assert.Throws( () => dataFrame.InsertColumn(10, repeatedName)); + + Assert.Equal(2, dataFrame.ColumnCount); + BaseDataFrameColumn intColumnCopy = new PrimitiveDataFrameColumn("IntColumn", Enumerable.Range(0, 10).Select(x => x)); + Assert.Throws(() => dataFrame.SetColumn(1, intColumnCopy)); + + BaseDataFrameColumn differentIntColumn = new PrimitiveDataFrameColumn("IntColumn1", Enumerable.Range(0, 10).Select(x => x)); + dataFrame.SetColumn(1, differentIntColumn); + Assert.True(differentIntColumn == dataFrame.Column(1)); + + dataFrame.RemoveColumn(1); + Assert.Equal(1, dataFrame.ColumnCount); + Assert.True(intColumn == dataFrame.Column(0)); + } + + [Fact] + public void TestBinaryOperations() + { + DataFrame df = DataFrameTests.MakeTestTableWithTwoColumns(10); + // Binary ops always return a copy + Assert.Equal(5, df.Add(5)[0, 0]); + IReadOnlyList listOfInts = new List() { 5, 5 }; + Assert.Equal(5, df.Add(listOfInts)[0, 0]); + Assert.Equal(-5, df.Subtract(5)[0, 0]); + Assert.Equal(-5, df.Subtract(listOfInts)[0, 0]); + Assert.Equal(5, df.Multiply(5)[1, 0]); + Assert.Equal(5, df.Multiply(listOfInts)[1, 0]); + Assert.Equal(1, df.Divide(5)[5, 0]); + Assert.Equal(1, df.Divide(listOfInts)[5, 0]); + Assert.Equal(0, df.Modulo(5)[5, 0]); + Assert.Equal(0, df.Modulo(listOfInts)[5, 0]); + Assert.Equal(5, df.And(5)[5, 0]); + Assert.Equal(5, df.And(listOfInts)[5, 0]); + Assert.Equal(5, df.Or(5)[5, 0]); + Assert.Equal(5, df.Or(listOfInts)[5, 0]); + Assert.Equal(0, df.Xor(5)[5, 0]); + Assert.Equal(0, df.Xor(listOfInts)[5, 0]); + Assert.Equal(2, df.LeftShift(1)[1, 0]); + Assert.Equal(1, df.RightShift(1)[2, 0]); + Assert.Equal(true, df.Equals(5)[5, 0]); + Assert.Equal(true, df.Equals(listOfInts)[5, 0]); + Assert.Equal(true, df.NotEquals(5)[4, 0]); + Assert.Equal(true, df.NotEquals(listOfInts)[4, 0]); + Assert.Equal(true, df.GreaterThanOrEqual(5)[6, 0]); + Assert.Equal(true, df.GreaterThanOrEqual(listOfInts)[6, 0]); + Assert.Equal(true, df.LessThanOrEqual(5)[4, 0]); + Assert.Equal(true, df.LessThanOrEqual(listOfInts)[4, 0]); + Assert.Equal(false, df.GreaterThan(5)[5, 0]); + Assert.Equal(false, df.GreaterThan(listOfInts)[5, 0]); + Assert.Equal(false, df.LessThan(5)[5, 0]); + Assert.Equal(false, df.LessThan(listOfInts)[5, 0]); + + // The original DF is untouched + Assert.Equal(0, df[0, 0]); + } + // TODO: Add tests for other column types + } +} diff --git a/tests/Microsoft.Data.Tests/Microsoft.Data.Tests.csproj b/tests/Microsoft.Data.Tests/Microsoft.Data.Tests.csproj new file mode 100644 index 00000000000..9b3a69c68af --- /dev/null +++ b/tests/Microsoft.Data.Tests/Microsoft.Data.Tests.csproj @@ -0,0 +1,17 @@ + + + + netcoreapp2.2 + + + + + + + + + + + + + From 196ad6fb1513e17fdf8e1b3091727b10ae5baed9 Mon Sep 17 00:00:00 2001 From: Prashanth Govindarajan Date: Wed, 17 Apr 2019 14:41:10 -0700 Subject: [PATCH 2/8] Rename ii to i --- src/Microsoft.Data/DataFrame.cs | 12 +- .../DataFrameBinaryOperations.cs | 208 +-- .../DataFrameBinaryOperations.tt | 10 +- src/Microsoft.Data/DataFrameBuffer.cs | 8 +- src/Microsoft.Data/DataFrameTable.cs | 4 +- .../PrimitiveDataFrameColumnArithmetic.cs | 1384 ++++++++--------- .../PrimitiveDataFrameColumnArithmetic.tt | 10 +- .../PrimitiveDataFrameColumnContainer.cs | 6 +- 8 files changed, 821 insertions(+), 821 deletions(-) diff --git a/src/Microsoft.Data/DataFrame.cs b/src/Microsoft.Data/DataFrame.cs index 82aa93002dc..3c081625457 100644 --- a/src/Microsoft.Data/DataFrame.cs +++ b/src/Microsoft.Data/DataFrame.cs @@ -23,9 +23,9 @@ public DataFrame() public IList Columns() { var ret = new List(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - ret.Add(_table.Column(ii).Name); + ret.Add(_table.Column(i).Name); } return ret; } @@ -70,9 +70,9 @@ public object this[string columnName] public IList> Head(int numberOfRows) { var ret = new List>(); - for (int ii = 0; ii < numberOfRows; ii++) + for (int i= 0; i< numberOfRows; i++) { - ret.Add(this[ii]); + ret.Add(this[i]); } return ret; } @@ -80,9 +80,9 @@ public IList> Head(int numberOfRows) public IList> Tail(int numberOfRows) { var ret = new List>(); - for (long ii = RowCount - numberOfRows; ii < RowCount; ii++) + for (long i = RowCount - numberOfRows; i < RowCount; i++) { - ret.Add(this[ii]); + ret.Add(this[i]); } return ret; } diff --git a/src/Microsoft.Data/DataFrameBinaryOperations.cs b/src/Microsoft.Data/DataFrameBinaryOperations.cs index c8cd096ef91..f8f3a9943fb 100644 --- a/src/Microsoft.Data/DataFrameBinaryOperations.cs +++ b/src/Microsoft.Data/DataFrameBinaryOperations.cs @@ -20,14 +20,14 @@ public DataFrame Add(IReadOnlyList values) throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); } var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { var newColumn = column.Clone(); - newColumn._columnContainer.Add(values[ii]); - newDataFrame.InsertColumn(ii, newColumn); + newColumn._columnContainer.Add(values[i]); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -37,14 +37,14 @@ public DataFrame Add(T value) where T : struct { var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { var newColumn = column.Clone(); newColumn._columnContainer.Add(value); - newDataFrame.InsertColumn(ii, newColumn); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -58,14 +58,14 @@ public DataFrame Subtract(IReadOnlyList values) throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); } var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { var newColumn = column.Clone(); - newColumn._columnContainer.Subtract(values[ii]); - newDataFrame.InsertColumn(ii, newColumn); + newColumn._columnContainer.Subtract(values[i]); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -75,14 +75,14 @@ public DataFrame Subtract(T value) where T : struct { var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { var newColumn = column.Clone(); newColumn._columnContainer.Subtract(value); - newDataFrame.InsertColumn(ii, newColumn); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -96,14 +96,14 @@ public DataFrame Multiply(IReadOnlyList values) throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); } var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { var newColumn = column.Clone(); - newColumn._columnContainer.Multiply(values[ii]); - newDataFrame.InsertColumn(ii, newColumn); + newColumn._columnContainer.Multiply(values[i]); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -113,14 +113,14 @@ public DataFrame Multiply(T value) where T : struct { var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { var newColumn = column.Clone(); newColumn._columnContainer.Multiply(value); - newDataFrame.InsertColumn(ii, newColumn); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -134,14 +134,14 @@ public DataFrame Divide(IReadOnlyList values) throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); } var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { var newColumn = column.Clone(); - newColumn._columnContainer.Divide(values[ii]); - newDataFrame.InsertColumn(ii, newColumn); + newColumn._columnContainer.Divide(values[i]); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -151,14 +151,14 @@ public DataFrame Divide(T value) where T : struct { var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { var newColumn = column.Clone(); newColumn._columnContainer.Divide(value); - newDataFrame.InsertColumn(ii, newColumn); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -172,14 +172,14 @@ public DataFrame Modulo(IReadOnlyList values) throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); } var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { var newColumn = column.Clone(); - newColumn._columnContainer.Modulo(values[ii]); - newDataFrame.InsertColumn(ii, newColumn); + newColumn._columnContainer.Modulo(values[i]); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -189,14 +189,14 @@ public DataFrame Modulo(T value) where T : struct { var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { var newColumn = column.Clone(); newColumn._columnContainer.Modulo(value); - newDataFrame.InsertColumn(ii, newColumn); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -210,14 +210,14 @@ public DataFrame And(IReadOnlyList values) throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); } var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { var newColumn = column.Clone(); - newColumn._columnContainer.And(values[ii]); - newDataFrame.InsertColumn(ii, newColumn); + newColumn._columnContainer.And(values[i]); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -227,14 +227,14 @@ public DataFrame And(T value) where T : struct { var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { var newColumn = column.Clone(); newColumn._columnContainer.And(value); - newDataFrame.InsertColumn(ii, newColumn); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -248,14 +248,14 @@ public DataFrame Or(IReadOnlyList values) throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); } var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { var newColumn = column.Clone(); - newColumn._columnContainer.Or(values[ii]); - newDataFrame.InsertColumn(ii, newColumn); + newColumn._columnContainer.Or(values[i]); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -265,14 +265,14 @@ public DataFrame Or(T value) where T : struct { var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { var newColumn = column.Clone(); newColumn._columnContainer.Or(value); - newDataFrame.InsertColumn(ii, newColumn); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -286,14 +286,14 @@ public DataFrame Xor(IReadOnlyList values) throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); } var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { var newColumn = column.Clone(); - newColumn._columnContainer.Xor(values[ii]); - newDataFrame.InsertColumn(ii, newColumn); + newColumn._columnContainer.Xor(values[i]); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -303,14 +303,14 @@ public DataFrame Xor(T value) where T : struct { var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { var newColumn = column.Clone(); newColumn._columnContainer.Xor(value); - newDataFrame.InsertColumn(ii, newColumn); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -320,14 +320,14 @@ public DataFrame LeftShift(int value) where T : struct { var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { var newColumn = column.Clone(); newColumn._columnContainer.LeftShift(value); - newDataFrame.InsertColumn(ii, newColumn); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -337,14 +337,14 @@ public DataFrame RightShift(int value) where T : struct { var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { var newColumn = column.Clone(); newColumn._columnContainer.RightShift(value); - newDataFrame.InsertColumn(ii, newColumn); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -358,14 +358,14 @@ public DataFrame Equals(IReadOnlyList values) throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); } var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); - column._columnContainer.Equals(values[ii], newColumn._columnContainer); - newDataFrame.InsertColumn(ii, newColumn); + column._columnContainer.Equals(values[i], newColumn._columnContainer); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -375,14 +375,14 @@ public DataFrame Equals(T value) where T : struct { var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); column._columnContainer.Equals(value, newColumn._columnContainer); - newDataFrame.InsertColumn(ii, newColumn); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -396,14 +396,14 @@ public DataFrame NotEquals(IReadOnlyList values) throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); } var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); - column._columnContainer.NotEquals(values[ii], newColumn._columnContainer); - newDataFrame.InsertColumn(ii, newColumn); + column._columnContainer.NotEquals(values[i], newColumn._columnContainer); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -413,14 +413,14 @@ public DataFrame NotEquals(T value) where T : struct { var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); column._columnContainer.NotEquals(value, newColumn._columnContainer); - newDataFrame.InsertColumn(ii, newColumn); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -434,14 +434,14 @@ public DataFrame GreaterThanOrEqual(IReadOnlyList values) throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); } var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); - column._columnContainer.GreaterThanOrEqual(values[ii], newColumn._columnContainer); - newDataFrame.InsertColumn(ii, newColumn); + column._columnContainer.GreaterThanOrEqual(values[i], newColumn._columnContainer); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -451,14 +451,14 @@ public DataFrame GreaterThanOrEqual(T value) where T : struct { var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); column._columnContainer.GreaterThanOrEqual(value, newColumn._columnContainer); - newDataFrame.InsertColumn(ii, newColumn); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -472,14 +472,14 @@ public DataFrame LessThanOrEqual(IReadOnlyList values) throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); } var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); - column._columnContainer.LessThanOrEqual(values[ii], newColumn._columnContainer); - newDataFrame.InsertColumn(ii, newColumn); + column._columnContainer.LessThanOrEqual(values[i], newColumn._columnContainer); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -489,14 +489,14 @@ public DataFrame LessThanOrEqual(T value) where T : struct { var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); column._columnContainer.LessThanOrEqual(value, newColumn._columnContainer); - newDataFrame.InsertColumn(ii, newColumn); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -510,14 +510,14 @@ public DataFrame GreaterThan(IReadOnlyList values) throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); } var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); - column._columnContainer.GreaterThan(values[ii], newColumn._columnContainer); - newDataFrame.InsertColumn(ii, newColumn); + column._columnContainer.GreaterThan(values[i], newColumn._columnContainer); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -527,14 +527,14 @@ public DataFrame GreaterThan(T value) where T : struct { var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); column._columnContainer.GreaterThan(value, newColumn._columnContainer); - newDataFrame.InsertColumn(ii, newColumn); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -548,14 +548,14 @@ public DataFrame LessThan(IReadOnlyList values) throw new ArgumentException($"values.Count {values.Count} must match the number of columns in the table", nameof(values)); } var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); - column._columnContainer.LessThan(values[ii], newColumn._columnContainer); - newDataFrame.InsertColumn(ii, newColumn); + column._columnContainer.LessThan(values[i], newColumn._columnContainer); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; @@ -565,14 +565,14 @@ public DataFrame LessThan(T value) where T : struct { var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { PrimitiveDataFrameColumn newColumn = column.CreateBoolColumnForCompareOps(); column._columnContainer.LessThan(value, newColumn._columnContainer); - newDataFrame.InsertColumn(ii, newColumn); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; diff --git a/src/Microsoft.Data/DataFrameBinaryOperations.tt b/src/Microsoft.Data/DataFrameBinaryOperations.tt index 87c138346bd..64244e12cfc 100644 --- a/src/Microsoft.Data/DataFrameBinaryOperations.tt +++ b/src/Microsoft.Data/DataFrameBinaryOperations.tt @@ -36,9 +36,9 @@ namespace Microsoft.Data } <# } #> var newDataFrame = new DataFrame(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - PrimitiveDataFrameColumn column = _table.Column(ii) as PrimitiveDataFrameColumn; + PrimitiveDataFrameColumn column = _table.Column(i) as PrimitiveDataFrameColumn; if (column != null) { <# if (method.MethodType == MethodType.ComparisonScalar || method.MethodType == MethodType.Comparison) { #> @@ -46,16 +46,16 @@ namespace Microsoft.Data <# if (method.MethodType == MethodType.ComparisonScalar) { #> column._columnContainer.<#=method.MethodName#>(value, newColumn._columnContainer); <# } else { #> - column._columnContainer.<#=method.MethodName#>(values[ii], newColumn._columnContainer); + column._columnContainer.<#=method.MethodName#>(values[i], newColumn._columnContainer); <# } #> <# } else if (method.MethodType == MethodType.BinaryScalar || method.MethodType == MethodType.BinaryInt) { #> var newColumn = column.Clone(); newColumn._columnContainer.<#=method.MethodName#>(value); <# } else { #> var newColumn = column.Clone(); - newColumn._columnContainer.<#=method.MethodName#>(values[ii]); + newColumn._columnContainer.<#=method.MethodName#>(values[i]); <# } #> - newDataFrame.InsertColumn(ii, newColumn); + newDataFrame.InsertColumn(i, newColumn); } } return newDataFrame; diff --git a/src/Microsoft.Data/DataFrameBuffer.cs b/src/Microsoft.Data/DataFrameBuffer.cs index db8d09932b4..b30711eee35 100644 --- a/src/Microsoft.Data/DataFrameBuffer.cs +++ b/src/Microsoft.Data/DataFrameBuffer.cs @@ -87,9 +87,9 @@ internal T this[int index] { if (startIndex > Length) throw new ArgumentOutOfRangeException(nameof(startIndex)); long endIndex = Math.Min(Length, startIndex + length); - for (int ii = startIndex; ii < endIndex; ii++) + for (int i = startIndex; i < endIndex; i++) { - returnList.Add(Span[ii]); + returnList.Add(Span[i]); } return true; } @@ -98,9 +98,9 @@ public override string ToString() { string ret = ""; Span span = Span; - for (int ii = 0; ii < Length; ii++) + for (int i = 0; i < Length; i++) { - ret += span[ii] + " "; + ret += span[i] + " "; } return ret; } diff --git a/src/Microsoft.Data/DataFrameTable.cs b/src/Microsoft.Data/DataFrameTable.cs index 6b4b36b212f..10f3666d34a 100644 --- a/src/Microsoft.Data/DataFrameTable.cs +++ b/src/Microsoft.Data/DataFrameTable.cs @@ -46,9 +46,9 @@ public DataFrameTable(BaseDataFrameColumn column) : this(new List GetRow(long rowIndex) { var ret = new List(); - for (int ii = 0; ii < ColumnCount; ii++) + for (int i = 0; i < ColumnCount; i++) { - ret.Add(Column(ii)[rowIndex]); + ret.Add(Column(i)[rowIndex]); } return ret; } diff --git a/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.cs b/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.cs index 0968e723f12..e799dd70a89 100644 --- a/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.cs +++ b/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.cs @@ -157,9 +157,9 @@ public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrame for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (bool)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + buffer.Span[i] = (bool)(buffer.Span[i] & right.Buffers[bb].Span[i]); } } } @@ -168,9 +168,9 @@ public void And(PrimitiveDataFrameColumnContainer column, bool scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (bool)(buffer.Span[ii] & scalar); + buffer.Span[i] = (bool)(buffer.Span[i] & scalar); } } } @@ -179,9 +179,9 @@ public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameC for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (bool)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + buffer.Span[i] = (bool)(buffer.Span[i] | right.Buffers[bb].Span[i]); } } } @@ -190,9 +190,9 @@ public void Or(PrimitiveDataFrameColumnContainer column, bool scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (bool)(buffer.Span[ii] | scalar); + buffer.Span[i] = (bool)(buffer.Span[i] | scalar); } } } @@ -201,9 +201,9 @@ public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrame for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (bool)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + buffer.Span[i] = (bool)(buffer.Span[i] ^ right.Buffers[bb].Span[i]); } } } @@ -212,9 +212,9 @@ public void Xor(PrimitiveDataFrameColumnContainer column, bool scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (bool)(buffer.Span[ii] ^ scalar); + buffer.Span[i] = (bool)(buffer.Span[i] ^ scalar); } } } @@ -231,9 +231,9 @@ public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFr for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] == right.Buffers[bb].Span[i]); } } } @@ -242,9 +242,9 @@ public void Equals(PrimitiveDataFrameColumnContainer column, bool scalar, for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == scalar); + ret[i] = (buffer.Span[i] == scalar); } } } @@ -253,9 +253,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] != right.Buffers[bb].Span[i]); } } } @@ -264,9 +264,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer column, bool scala for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != scalar); + ret[i] = (buffer.Span[i] != scalar); } } } @@ -310,9 +310,9 @@ public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrame for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (byte)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + buffer.Span[i] = (byte)(buffer.Span[i] + right.Buffers[bb].Span[i]); } } } @@ -321,9 +321,9 @@ public void Add(PrimitiveDataFrameColumnContainer column, byte scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (byte)(buffer.Span[ii] + scalar); + buffer.Span[i] = (byte)(buffer.Span[i] + scalar); } } } @@ -332,9 +332,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveData for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (byte)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + buffer.Span[i] = (byte)(buffer.Span[i] - right.Buffers[bb].Span[i]); } } } @@ -343,9 +343,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer column, byte scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (byte)(buffer.Span[ii] - scalar); + buffer.Span[i] = (byte)(buffer.Span[i] - scalar); } } } @@ -354,9 +354,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveData for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (byte)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + buffer.Span[i] = (byte)(buffer.Span[i] * right.Buffers[bb].Span[i]); } } } @@ -365,9 +365,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer column, byte scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (byte)(buffer.Span[ii] * scalar); + buffer.Span[i] = (byte)(buffer.Span[i] * scalar); } } } @@ -376,9 +376,9 @@ public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataFr for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (byte)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + buffer.Span[i] = (byte)(buffer.Span[i] / right.Buffers[bb].Span[i]); } } } @@ -387,9 +387,9 @@ public void Divide(PrimitiveDataFrameColumnContainer column, byte scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (byte)(buffer.Span[ii] / scalar); + buffer.Span[i] = (byte)(buffer.Span[i] / scalar); } } } @@ -398,9 +398,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataFr for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (byte)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + buffer.Span[i] = (byte)(buffer.Span[i] % right.Buffers[bb].Span[i]); } } } @@ -409,9 +409,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer column, byte scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (byte)(buffer.Span[ii] % scalar); + buffer.Span[i] = (byte)(buffer.Span[i] % scalar); } } } @@ -420,9 +420,9 @@ public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrame for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (byte)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + buffer.Span[i] = (byte)(buffer.Span[i] & right.Buffers[bb].Span[i]); } } } @@ -431,9 +431,9 @@ public void And(PrimitiveDataFrameColumnContainer column, byte scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (byte)(buffer.Span[ii] & scalar); + buffer.Span[i] = (byte)(buffer.Span[i] & scalar); } } } @@ -442,9 +442,9 @@ public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameC for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (byte)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + buffer.Span[i] = (byte)(buffer.Span[i] | right.Buffers[bb].Span[i]); } } } @@ -453,9 +453,9 @@ public void Or(PrimitiveDataFrameColumnContainer column, byte scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (byte)(buffer.Span[ii] | scalar); + buffer.Span[i] = (byte)(buffer.Span[i] | scalar); } } } @@ -464,9 +464,9 @@ public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrame for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (byte)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + buffer.Span[i] = (byte)(buffer.Span[i] ^ right.Buffers[bb].Span[i]); } } } @@ -475,9 +475,9 @@ public void Xor(PrimitiveDataFrameColumnContainer column, byte scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (byte)(buffer.Span[ii] ^ scalar); + buffer.Span[i] = (byte)(buffer.Span[i] ^ scalar); } } } @@ -486,9 +486,9 @@ public void LeftShift(PrimitiveDataFrameColumnContainer column, int value) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (byte)(buffer.Span[ii] << value); + buffer.Span[i] = (byte)(buffer.Span[i] << value); } } } @@ -497,9 +497,9 @@ public void RightShift(PrimitiveDataFrameColumnContainer column, int value for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (byte)(buffer.Span[ii] >> value); + buffer.Span[i] = (byte)(buffer.Span[i] >> value); } } } @@ -508,9 +508,9 @@ public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFr for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] == right.Buffers[bb].Span[i]); } } } @@ -519,9 +519,9 @@ public void Equals(PrimitiveDataFrameColumnContainer column, byte scalar, for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == scalar); + ret[i] = (buffer.Span[i] == scalar); } } } @@ -530,9 +530,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] != right.Buffers[bb].Span[i]); } } } @@ -541,9 +541,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer column, byte scala for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != scalar); + ret[i] = (buffer.Span[i] != scalar); } } } @@ -552,9 +552,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, Pri for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] >= right.Buffers[bb].Span[i]); } } } @@ -563,9 +563,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, b for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= scalar); + ret[i] = (buffer.Span[i] >= scalar); } } } @@ -574,9 +574,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, Primit for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] <= right.Buffers[bb].Span[i]); } } } @@ -585,9 +585,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, byte for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= scalar); + ret[i] = (buffer.Span[i] <= scalar); } } } @@ -596,9 +596,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer left, PrimitiveD for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] > right.Buffers[bb].Span[i]); } } } @@ -607,9 +607,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer column, byte sca for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > scalar); + ret[i] = (buffer.Span[i] > scalar); } } } @@ -618,9 +618,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveData for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] < right.Buffers[bb].Span[i]); } } } @@ -629,9 +629,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer column, byte scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < scalar); + ret[i] = (buffer.Span[i] < scalar); } } } @@ -643,9 +643,9 @@ public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrame for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (char)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + buffer.Span[i] = (char)(buffer.Span[i] + right.Buffers[bb].Span[i]); } } } @@ -654,9 +654,9 @@ public void Add(PrimitiveDataFrameColumnContainer column, char scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (char)(buffer.Span[ii] + scalar); + buffer.Span[i] = (char)(buffer.Span[i] + scalar); } } } @@ -665,9 +665,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveData for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (char)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + buffer.Span[i] = (char)(buffer.Span[i] - right.Buffers[bb].Span[i]); } } } @@ -676,9 +676,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer column, char scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (char)(buffer.Span[ii] - scalar); + buffer.Span[i] = (char)(buffer.Span[i] - scalar); } } } @@ -687,9 +687,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveData for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (char)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + buffer.Span[i] = (char)(buffer.Span[i] * right.Buffers[bb].Span[i]); } } } @@ -698,9 +698,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer column, char scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (char)(buffer.Span[ii] * scalar); + buffer.Span[i] = (char)(buffer.Span[i] * scalar); } } } @@ -709,9 +709,9 @@ public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataFr for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (char)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + buffer.Span[i] = (char)(buffer.Span[i] / right.Buffers[bb].Span[i]); } } } @@ -720,9 +720,9 @@ public void Divide(PrimitiveDataFrameColumnContainer column, char scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (char)(buffer.Span[ii] / scalar); + buffer.Span[i] = (char)(buffer.Span[i] / scalar); } } } @@ -731,9 +731,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataFr for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (char)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + buffer.Span[i] = (char)(buffer.Span[i] % right.Buffers[bb].Span[i]); } } } @@ -742,9 +742,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer column, char scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (char)(buffer.Span[ii] % scalar); + buffer.Span[i] = (char)(buffer.Span[i] % scalar); } } } @@ -753,9 +753,9 @@ public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrame for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (char)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + buffer.Span[i] = (char)(buffer.Span[i] & right.Buffers[bb].Span[i]); } } } @@ -764,9 +764,9 @@ public void And(PrimitiveDataFrameColumnContainer column, char scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (char)(buffer.Span[ii] & scalar); + buffer.Span[i] = (char)(buffer.Span[i] & scalar); } } } @@ -775,9 +775,9 @@ public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameC for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (char)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + buffer.Span[i] = (char)(buffer.Span[i] | right.Buffers[bb].Span[i]); } } } @@ -786,9 +786,9 @@ public void Or(PrimitiveDataFrameColumnContainer column, char scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (char)(buffer.Span[ii] | scalar); + buffer.Span[i] = (char)(buffer.Span[i] | scalar); } } } @@ -797,9 +797,9 @@ public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrame for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (char)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + buffer.Span[i] = (char)(buffer.Span[i] ^ right.Buffers[bb].Span[i]); } } } @@ -808,9 +808,9 @@ public void Xor(PrimitiveDataFrameColumnContainer column, char scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (char)(buffer.Span[ii] ^ scalar); + buffer.Span[i] = (char)(buffer.Span[i] ^ scalar); } } } @@ -819,9 +819,9 @@ public void LeftShift(PrimitiveDataFrameColumnContainer column, int value) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (char)(buffer.Span[ii] << value); + buffer.Span[i] = (char)(buffer.Span[i] << value); } } } @@ -830,9 +830,9 @@ public void RightShift(PrimitiveDataFrameColumnContainer column, int value for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (char)(buffer.Span[ii] >> value); + buffer.Span[i] = (char)(buffer.Span[i] >> value); } } } @@ -841,9 +841,9 @@ public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFr for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] == right.Buffers[bb].Span[i]); } } } @@ -852,9 +852,9 @@ public void Equals(PrimitiveDataFrameColumnContainer column, char scalar, for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == scalar); + ret[i] = (buffer.Span[i] == scalar); } } } @@ -863,9 +863,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] != right.Buffers[bb].Span[i]); } } } @@ -874,9 +874,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer column, char scala for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != scalar); + ret[i] = (buffer.Span[i] != scalar); } } } @@ -885,9 +885,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, Pri for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] >= right.Buffers[bb].Span[i]); } } } @@ -896,9 +896,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, c for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= scalar); + ret[i] = (buffer.Span[i] >= scalar); } } } @@ -907,9 +907,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, Primit for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] <= right.Buffers[bb].Span[i]); } } } @@ -918,9 +918,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, char for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= scalar); + ret[i] = (buffer.Span[i] <= scalar); } } } @@ -929,9 +929,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer left, PrimitiveD for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] > right.Buffers[bb].Span[i]); } } } @@ -940,9 +940,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer column, char sca for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > scalar); + ret[i] = (buffer.Span[i] > scalar); } } } @@ -951,9 +951,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveData for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] < right.Buffers[bb].Span[i]); } } } @@ -962,9 +962,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer column, char scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < scalar); + ret[i] = (buffer.Span[i] < scalar); } } } @@ -976,9 +976,9 @@ public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFr for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (decimal)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + buffer.Span[i] = (decimal)(buffer.Span[i] + right.Buffers[bb].Span[i]); } } } @@ -987,9 +987,9 @@ public void Add(PrimitiveDataFrameColumnContainer column, decimal scala for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (decimal)(buffer.Span[ii] + scalar); + buffer.Span[i] = (decimal)(buffer.Span[i] + scalar); } } } @@ -998,9 +998,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveD for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (decimal)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + buffer.Span[i] = (decimal)(buffer.Span[i] - right.Buffers[bb].Span[i]); } } } @@ -1009,9 +1009,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer column, decimal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (decimal)(buffer.Span[ii] - scalar); + buffer.Span[i] = (decimal)(buffer.Span[i] - scalar); } } } @@ -1020,9 +1020,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveD for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (decimal)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + buffer.Span[i] = (decimal)(buffer.Span[i] * right.Buffers[bb].Span[i]); } } } @@ -1031,9 +1031,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer column, decimal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (decimal)(buffer.Span[ii] * scalar); + buffer.Span[i] = (decimal)(buffer.Span[i] * scalar); } } } @@ -1042,9 +1042,9 @@ public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (decimal)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + buffer.Span[i] = (decimal)(buffer.Span[i] / right.Buffers[bb].Span[i]); } } } @@ -1053,9 +1053,9 @@ public void Divide(PrimitiveDataFrameColumnContainer column, decimal sc for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (decimal)(buffer.Span[ii] / scalar); + buffer.Span[i] = (decimal)(buffer.Span[i] / scalar); } } } @@ -1064,9 +1064,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (decimal)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + buffer.Span[i] = (decimal)(buffer.Span[i] % right.Buffers[bb].Span[i]); } } } @@ -1075,9 +1075,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer column, decimal sc for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (decimal)(buffer.Span[ii] % scalar); + buffer.Span[i] = (decimal)(buffer.Span[i] % scalar); } } } @@ -1118,9 +1118,9 @@ public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] == right.Buffers[bb].Span[i]); } } } @@ -1129,9 +1129,9 @@ public void Equals(PrimitiveDataFrameColumnContainer column, decimal sc for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == scalar); + ret[i] = (buffer.Span[i] == scalar); } } } @@ -1140,9 +1140,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer left, Primitive for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] != right.Buffers[bb].Span[i]); } } } @@ -1151,9 +1151,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer column, decimal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != scalar); + ret[i] = (buffer.Span[i] != scalar); } } } @@ -1162,9 +1162,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] >= right.Buffers[bb].Span[i]); } } } @@ -1173,9 +1173,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= scalar); + ret[i] = (buffer.Span[i] >= scalar); } } } @@ -1184,9 +1184,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, Pri for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] <= right.Buffers[bb].Span[i]); } } } @@ -1195,9 +1195,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, d for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= scalar); + ret[i] = (buffer.Span[i] <= scalar); } } } @@ -1206,9 +1206,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer left, Primiti for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] > right.Buffers[bb].Span[i]); } } } @@ -1217,9 +1217,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer column, decim for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > scalar); + ret[i] = (buffer.Span[i] > scalar); } } } @@ -1228,9 +1228,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveD for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] < right.Buffers[bb].Span[i]); } } } @@ -1239,9 +1239,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer column, decimal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < scalar); + ret[i] = (buffer.Span[i] < scalar); } } } @@ -1253,9 +1253,9 @@ public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFra for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (double)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + buffer.Span[i] = (double)(buffer.Span[i] + right.Buffers[bb].Span[i]); } } } @@ -1264,9 +1264,9 @@ public void Add(PrimitiveDataFrameColumnContainer column, double scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (double)(buffer.Span[ii] + scalar); + buffer.Span[i] = (double)(buffer.Span[i] + scalar); } } } @@ -1275,9 +1275,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDa for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (double)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + buffer.Span[i] = (double)(buffer.Span[i] - right.Buffers[bb].Span[i]); } } } @@ -1286,9 +1286,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer column, double sc for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (double)(buffer.Span[ii] - scalar); + buffer.Span[i] = (double)(buffer.Span[i] - scalar); } } } @@ -1297,9 +1297,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDa for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (double)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + buffer.Span[i] = (double)(buffer.Span[i] * right.Buffers[bb].Span[i]); } } } @@ -1308,9 +1308,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer column, double sc for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (double)(buffer.Span[ii] * scalar); + buffer.Span[i] = (double)(buffer.Span[i] * scalar); } } } @@ -1319,9 +1319,9 @@ public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveData for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (double)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + buffer.Span[i] = (double)(buffer.Span[i] / right.Buffers[bb].Span[i]); } } } @@ -1330,9 +1330,9 @@ public void Divide(PrimitiveDataFrameColumnContainer column, double scal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (double)(buffer.Span[ii] / scalar); + buffer.Span[i] = (double)(buffer.Span[i] / scalar); } } } @@ -1341,9 +1341,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveData for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (double)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + buffer.Span[i] = (double)(buffer.Span[i] % right.Buffers[bb].Span[i]); } } } @@ -1352,9 +1352,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer column, double scal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (double)(buffer.Span[ii] % scalar); + buffer.Span[i] = (double)(buffer.Span[i] % scalar); } } } @@ -1395,9 +1395,9 @@ public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveData for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] == right.Buffers[bb].Span[i]); } } } @@ -1406,9 +1406,9 @@ public void Equals(PrimitiveDataFrameColumnContainer column, double scal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == scalar); + ret[i] = (buffer.Span[i] == scalar); } } } @@ -1417,9 +1417,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveD for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] != right.Buffers[bb].Span[i]); } } } @@ -1428,9 +1428,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer column, double s for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != scalar); + ret[i] = (buffer.Span[i] != scalar); } } } @@ -1439,9 +1439,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, P for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] >= right.Buffers[bb].Span[i]); } } } @@ -1450,9 +1450,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= scalar); + ret[i] = (buffer.Span[i] >= scalar); } } } @@ -1461,9 +1461,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, Prim for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] <= right.Buffers[bb].Span[i]); } } } @@ -1472,9 +1472,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, do for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= scalar); + ret[i] = (buffer.Span[i] <= scalar); } } } @@ -1483,9 +1483,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer left, Primitiv for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] > right.Buffers[bb].Span[i]); } } } @@ -1494,9 +1494,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer column, double for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > scalar); + ret[i] = (buffer.Span[i] > scalar); } } } @@ -1505,9 +1505,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDa for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] < right.Buffers[bb].Span[i]); } } } @@ -1516,9 +1516,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer column, double sc for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < scalar); + ret[i] = (buffer.Span[i] < scalar); } } } @@ -1530,9 +1530,9 @@ public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFram for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (float)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + buffer.Span[i] = (float)(buffer.Span[i] + right.Buffers[bb].Span[i]); } } } @@ -1541,9 +1541,9 @@ public void Add(PrimitiveDataFrameColumnContainer column, float scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (float)(buffer.Span[ii] + scalar); + buffer.Span[i] = (float)(buffer.Span[i] + scalar); } } } @@ -1552,9 +1552,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (float)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + buffer.Span[i] = (float)(buffer.Span[i] - right.Buffers[bb].Span[i]); } } } @@ -1563,9 +1563,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer column, float scal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (float)(buffer.Span[ii] - scalar); + buffer.Span[i] = (float)(buffer.Span[i] - scalar); } } } @@ -1574,9 +1574,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (float)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + buffer.Span[i] = (float)(buffer.Span[i] * right.Buffers[bb].Span[i]); } } } @@ -1585,9 +1585,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer column, float scal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (float)(buffer.Span[ii] * scalar); + buffer.Span[i] = (float)(buffer.Span[i] * scalar); } } } @@ -1596,9 +1596,9 @@ public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataF for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (float)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + buffer.Span[i] = (float)(buffer.Span[i] / right.Buffers[bb].Span[i]); } } } @@ -1607,9 +1607,9 @@ public void Divide(PrimitiveDataFrameColumnContainer column, float scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (float)(buffer.Span[ii] / scalar); + buffer.Span[i] = (float)(buffer.Span[i] / scalar); } } } @@ -1618,9 +1618,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataF for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (float)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + buffer.Span[i] = (float)(buffer.Span[i] % right.Buffers[bb].Span[i]); } } } @@ -1629,9 +1629,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer column, float scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (float)(buffer.Span[ii] % scalar); + buffer.Span[i] = (float)(buffer.Span[i] % scalar); } } } @@ -1672,9 +1672,9 @@ public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataF for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] == right.Buffers[bb].Span[i]); } } } @@ -1683,9 +1683,9 @@ public void Equals(PrimitiveDataFrameColumnContainer column, float scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == scalar); + ret[i] = (buffer.Span[i] == scalar); } } } @@ -1694,9 +1694,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDa for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] != right.Buffers[bb].Span[i]); } } } @@ -1705,9 +1705,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer column, float sca for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != scalar); + ret[i] = (buffer.Span[i] != scalar); } } } @@ -1716,9 +1716,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, Pr for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] >= right.Buffers[bb].Span[i]); } } } @@ -1727,9 +1727,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= scalar); + ret[i] = (buffer.Span[i] >= scalar); } } } @@ -1738,9 +1738,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, Primi for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] <= right.Buffers[bb].Span[i]); } } } @@ -1749,9 +1749,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, flo for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= scalar); + ret[i] = (buffer.Span[i] <= scalar); } } } @@ -1760,9 +1760,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer left, Primitive for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] > right.Buffers[bb].Span[i]); } } } @@ -1771,9 +1771,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer column, float s for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > scalar); + ret[i] = (buffer.Span[i] > scalar); } } } @@ -1782,9 +1782,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] < right.Buffers[bb].Span[i]); } } } @@ -1793,9 +1793,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer column, float scal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < scalar); + ret[i] = (buffer.Span[i] < scalar); } } } @@ -1807,9 +1807,9 @@ public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameC for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (int)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + buffer.Span[i] = (int)(buffer.Span[i] + right.Buffers[bb].Span[i]); } } } @@ -1818,9 +1818,9 @@ public void Add(PrimitiveDataFrameColumnContainer column, int scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (int)(buffer.Span[ii] + scalar); + buffer.Span[i] = (int)(buffer.Span[i] + scalar); } } } @@ -1829,9 +1829,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDataF for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (int)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + buffer.Span[i] = (int)(buffer.Span[i] - right.Buffers[bb].Span[i]); } } } @@ -1840,9 +1840,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer column, int scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (int)(buffer.Span[ii] - scalar); + buffer.Span[i] = (int)(buffer.Span[i] - scalar); } } } @@ -1851,9 +1851,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDataF for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (int)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + buffer.Span[i] = (int)(buffer.Span[i] * right.Buffers[bb].Span[i]); } } } @@ -1862,9 +1862,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer column, int scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (int)(buffer.Span[ii] * scalar); + buffer.Span[i] = (int)(buffer.Span[i] * scalar); } } } @@ -1873,9 +1873,9 @@ public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataFra for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (int)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + buffer.Span[i] = (int)(buffer.Span[i] / right.Buffers[bb].Span[i]); } } } @@ -1884,9 +1884,9 @@ public void Divide(PrimitiveDataFrameColumnContainer column, int scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (int)(buffer.Span[ii] / scalar); + buffer.Span[i] = (int)(buffer.Span[i] / scalar); } } } @@ -1895,9 +1895,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataFra for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (int)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + buffer.Span[i] = (int)(buffer.Span[i] % right.Buffers[bb].Span[i]); } } } @@ -1906,9 +1906,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer column, int scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (int)(buffer.Span[ii] % scalar); + buffer.Span[i] = (int)(buffer.Span[i] % scalar); } } } @@ -1917,9 +1917,9 @@ public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameC for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (int)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + buffer.Span[i] = (int)(buffer.Span[i] & right.Buffers[bb].Span[i]); } } } @@ -1928,9 +1928,9 @@ public void And(PrimitiveDataFrameColumnContainer column, int scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (int)(buffer.Span[ii] & scalar); + buffer.Span[i] = (int)(buffer.Span[i] & scalar); } } } @@ -1939,9 +1939,9 @@ public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameCo for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (int)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + buffer.Span[i] = (int)(buffer.Span[i] | right.Buffers[bb].Span[i]); } } } @@ -1950,9 +1950,9 @@ public void Or(PrimitiveDataFrameColumnContainer column, int scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (int)(buffer.Span[ii] | scalar); + buffer.Span[i] = (int)(buffer.Span[i] | scalar); } } } @@ -1961,9 +1961,9 @@ public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameC for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (int)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + buffer.Span[i] = (int)(buffer.Span[i] ^ right.Buffers[bb].Span[i]); } } } @@ -1972,9 +1972,9 @@ public void Xor(PrimitiveDataFrameColumnContainer column, int scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (int)(buffer.Span[ii] ^ scalar); + buffer.Span[i] = (int)(buffer.Span[i] ^ scalar); } } } @@ -1983,9 +1983,9 @@ public void LeftShift(PrimitiveDataFrameColumnContainer column, int value) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (int)(buffer.Span[ii] << value); + buffer.Span[i] = (int)(buffer.Span[i] << value); } } } @@ -1994,9 +1994,9 @@ public void RightShift(PrimitiveDataFrameColumnContainer column, int value) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (int)(buffer.Span[ii] >> value); + buffer.Span[i] = (int)(buffer.Span[i] >> value); } } } @@ -2005,9 +2005,9 @@ public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFra for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] == right.Buffers[bb].Span[i]); } } } @@ -2016,9 +2016,9 @@ public void Equals(PrimitiveDataFrameColumnContainer column, int scalar, Pr for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == scalar); + ret[i] = (buffer.Span[i] == scalar); } } } @@ -2027,9 +2027,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveData for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] != right.Buffers[bb].Span[i]); } } } @@ -2038,9 +2038,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer column, int scalar, for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != scalar); + ret[i] = (buffer.Span[i] != scalar); } } } @@ -2049,9 +2049,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, Prim for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] >= right.Buffers[bb].Span[i]); } } } @@ -2060,9 +2060,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, in for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= scalar); + ret[i] = (buffer.Span[i] >= scalar); } } } @@ -2071,9 +2071,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, Primiti for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] <= right.Buffers[bb].Span[i]); } } } @@ -2082,9 +2082,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, int s for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= scalar); + ret[i] = (buffer.Span[i] <= scalar); } } } @@ -2093,9 +2093,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer left, PrimitiveDa for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] > right.Buffers[bb].Span[i]); } } } @@ -2104,9 +2104,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer column, int scala for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > scalar); + ret[i] = (buffer.Span[i] > scalar); } } } @@ -2115,9 +2115,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDataF for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] < right.Buffers[bb].Span[i]); } } } @@ -2126,9 +2126,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer column, int scalar, for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < scalar); + ret[i] = (buffer.Span[i] < scalar); } } } @@ -2140,9 +2140,9 @@ public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrame for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (long)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + buffer.Span[i] = (long)(buffer.Span[i] + right.Buffers[bb].Span[i]); } } } @@ -2151,9 +2151,9 @@ public void Add(PrimitiveDataFrameColumnContainer column, long scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (long)(buffer.Span[ii] + scalar); + buffer.Span[i] = (long)(buffer.Span[i] + scalar); } } } @@ -2162,9 +2162,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveData for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (long)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + buffer.Span[i] = (long)(buffer.Span[i] - right.Buffers[bb].Span[i]); } } } @@ -2173,9 +2173,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer column, long scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (long)(buffer.Span[ii] - scalar); + buffer.Span[i] = (long)(buffer.Span[i] - scalar); } } } @@ -2184,9 +2184,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveData for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (long)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + buffer.Span[i] = (long)(buffer.Span[i] * right.Buffers[bb].Span[i]); } } } @@ -2195,9 +2195,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer column, long scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (long)(buffer.Span[ii] * scalar); + buffer.Span[i] = (long)(buffer.Span[i] * scalar); } } } @@ -2206,9 +2206,9 @@ public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataFr for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (long)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + buffer.Span[i] = (long)(buffer.Span[i] / right.Buffers[bb].Span[i]); } } } @@ -2217,9 +2217,9 @@ public void Divide(PrimitiveDataFrameColumnContainer column, long scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (long)(buffer.Span[ii] / scalar); + buffer.Span[i] = (long)(buffer.Span[i] / scalar); } } } @@ -2228,9 +2228,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataFr for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (long)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + buffer.Span[i] = (long)(buffer.Span[i] % right.Buffers[bb].Span[i]); } } } @@ -2239,9 +2239,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer column, long scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (long)(buffer.Span[ii] % scalar); + buffer.Span[i] = (long)(buffer.Span[i] % scalar); } } } @@ -2250,9 +2250,9 @@ public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrame for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (long)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + buffer.Span[i] = (long)(buffer.Span[i] & right.Buffers[bb].Span[i]); } } } @@ -2261,9 +2261,9 @@ public void And(PrimitiveDataFrameColumnContainer column, long scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (long)(buffer.Span[ii] & scalar); + buffer.Span[i] = (long)(buffer.Span[i] & scalar); } } } @@ -2272,9 +2272,9 @@ public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameC for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (long)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + buffer.Span[i] = (long)(buffer.Span[i] | right.Buffers[bb].Span[i]); } } } @@ -2283,9 +2283,9 @@ public void Or(PrimitiveDataFrameColumnContainer column, long scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (long)(buffer.Span[ii] | scalar); + buffer.Span[i] = (long)(buffer.Span[i] | scalar); } } } @@ -2294,9 +2294,9 @@ public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrame for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (long)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + buffer.Span[i] = (long)(buffer.Span[i] ^ right.Buffers[bb].Span[i]); } } } @@ -2305,9 +2305,9 @@ public void Xor(PrimitiveDataFrameColumnContainer column, long scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (long)(buffer.Span[ii] ^ scalar); + buffer.Span[i] = (long)(buffer.Span[i] ^ scalar); } } } @@ -2316,9 +2316,9 @@ public void LeftShift(PrimitiveDataFrameColumnContainer column, int value) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (long)(buffer.Span[ii] << value); + buffer.Span[i] = (long)(buffer.Span[i] << value); } } } @@ -2327,9 +2327,9 @@ public void RightShift(PrimitiveDataFrameColumnContainer column, int value for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (long)(buffer.Span[ii] >> value); + buffer.Span[i] = (long)(buffer.Span[i] >> value); } } } @@ -2338,9 +2338,9 @@ public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFr for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] == right.Buffers[bb].Span[i]); } } } @@ -2349,9 +2349,9 @@ public void Equals(PrimitiveDataFrameColumnContainer column, long scalar, for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == scalar); + ret[i] = (buffer.Span[i] == scalar); } } } @@ -2360,9 +2360,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] != right.Buffers[bb].Span[i]); } } } @@ -2371,9 +2371,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer column, long scala for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != scalar); + ret[i] = (buffer.Span[i] != scalar); } } } @@ -2382,9 +2382,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, Pri for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] >= right.Buffers[bb].Span[i]); } } } @@ -2393,9 +2393,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, l for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= scalar); + ret[i] = (buffer.Span[i] >= scalar); } } } @@ -2404,9 +2404,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, Primit for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] <= right.Buffers[bb].Span[i]); } } } @@ -2415,9 +2415,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, long for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= scalar); + ret[i] = (buffer.Span[i] <= scalar); } } } @@ -2426,9 +2426,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer left, PrimitiveD for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] > right.Buffers[bb].Span[i]); } } } @@ -2437,9 +2437,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer column, long sca for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > scalar); + ret[i] = (buffer.Span[i] > scalar); } } } @@ -2448,9 +2448,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveData for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] < right.Buffers[bb].Span[i]); } } } @@ -2459,9 +2459,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer column, long scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < scalar); + ret[i] = (buffer.Span[i] < scalar); } } } @@ -2473,9 +2473,9 @@ public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFram for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (sbyte)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + buffer.Span[i] = (sbyte)(buffer.Span[i] + right.Buffers[bb].Span[i]); } } } @@ -2484,9 +2484,9 @@ public void Add(PrimitiveDataFrameColumnContainer column, sbyte scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (sbyte)(buffer.Span[ii] + scalar); + buffer.Span[i] = (sbyte)(buffer.Span[i] + scalar); } } } @@ -2495,9 +2495,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (sbyte)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + buffer.Span[i] = (sbyte)(buffer.Span[i] - right.Buffers[bb].Span[i]); } } } @@ -2506,9 +2506,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer column, sbyte scal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (sbyte)(buffer.Span[ii] - scalar); + buffer.Span[i] = (sbyte)(buffer.Span[i] - scalar); } } } @@ -2517,9 +2517,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (sbyte)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + buffer.Span[i] = (sbyte)(buffer.Span[i] * right.Buffers[bb].Span[i]); } } } @@ -2528,9 +2528,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer column, sbyte scal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (sbyte)(buffer.Span[ii] * scalar); + buffer.Span[i] = (sbyte)(buffer.Span[i] * scalar); } } } @@ -2539,9 +2539,9 @@ public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataF for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (sbyte)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + buffer.Span[i] = (sbyte)(buffer.Span[i] / right.Buffers[bb].Span[i]); } } } @@ -2550,9 +2550,9 @@ public void Divide(PrimitiveDataFrameColumnContainer column, sbyte scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (sbyte)(buffer.Span[ii] / scalar); + buffer.Span[i] = (sbyte)(buffer.Span[i] / scalar); } } } @@ -2561,9 +2561,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataF for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (sbyte)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + buffer.Span[i] = (sbyte)(buffer.Span[i] % right.Buffers[bb].Span[i]); } } } @@ -2572,9 +2572,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer column, sbyte scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (sbyte)(buffer.Span[ii] % scalar); + buffer.Span[i] = (sbyte)(buffer.Span[i] % scalar); } } } @@ -2583,9 +2583,9 @@ public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFram for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (sbyte)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + buffer.Span[i] = (sbyte)(buffer.Span[i] & right.Buffers[bb].Span[i]); } } } @@ -2594,9 +2594,9 @@ public void And(PrimitiveDataFrameColumnContainer column, sbyte scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (sbyte)(buffer.Span[ii] & scalar); + buffer.Span[i] = (sbyte)(buffer.Span[i] & scalar); } } } @@ -2605,9 +2605,9 @@ public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrame for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (sbyte)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + buffer.Span[i] = (sbyte)(buffer.Span[i] | right.Buffers[bb].Span[i]); } } } @@ -2616,9 +2616,9 @@ public void Or(PrimitiveDataFrameColumnContainer column, sbyte scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (sbyte)(buffer.Span[ii] | scalar); + buffer.Span[i] = (sbyte)(buffer.Span[i] | scalar); } } } @@ -2627,9 +2627,9 @@ public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFram for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (sbyte)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + buffer.Span[i] = (sbyte)(buffer.Span[i] ^ right.Buffers[bb].Span[i]); } } } @@ -2638,9 +2638,9 @@ public void Xor(PrimitiveDataFrameColumnContainer column, sbyte scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (sbyte)(buffer.Span[ii] ^ scalar); + buffer.Span[i] = (sbyte)(buffer.Span[i] ^ scalar); } } } @@ -2649,9 +2649,9 @@ public void LeftShift(PrimitiveDataFrameColumnContainer column, int value for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (sbyte)(buffer.Span[ii] << value); + buffer.Span[i] = (sbyte)(buffer.Span[i] << value); } } } @@ -2660,9 +2660,9 @@ public void RightShift(PrimitiveDataFrameColumnContainer column, int valu for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (sbyte)(buffer.Span[ii] >> value); + buffer.Span[i] = (sbyte)(buffer.Span[i] >> value); } } } @@ -2671,9 +2671,9 @@ public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataF for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] == right.Buffers[bb].Span[i]); } } } @@ -2682,9 +2682,9 @@ public void Equals(PrimitiveDataFrameColumnContainer column, sbyte scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == scalar); + ret[i] = (buffer.Span[i] == scalar); } } } @@ -2693,9 +2693,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDa for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] != right.Buffers[bb].Span[i]); } } } @@ -2704,9 +2704,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer column, sbyte sca for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != scalar); + ret[i] = (buffer.Span[i] != scalar); } } } @@ -2715,9 +2715,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, Pr for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] >= right.Buffers[bb].Span[i]); } } } @@ -2726,9 +2726,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= scalar); + ret[i] = (buffer.Span[i] >= scalar); } } } @@ -2737,9 +2737,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, Primi for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] <= right.Buffers[bb].Span[i]); } } } @@ -2748,9 +2748,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, sby for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= scalar); + ret[i] = (buffer.Span[i] <= scalar); } } } @@ -2759,9 +2759,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer left, Primitive for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] > right.Buffers[bb].Span[i]); } } } @@ -2770,9 +2770,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer column, sbyte s for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > scalar); + ret[i] = (buffer.Span[i] > scalar); } } } @@ -2781,9 +2781,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] < right.Buffers[bb].Span[i]); } } } @@ -2792,9 +2792,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer column, sbyte scal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < scalar); + ret[i] = (buffer.Span[i] < scalar); } } } @@ -2806,9 +2806,9 @@ public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFram for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (short)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + buffer.Span[i] = (short)(buffer.Span[i] + right.Buffers[bb].Span[i]); } } } @@ -2817,9 +2817,9 @@ public void Add(PrimitiveDataFrameColumnContainer column, short scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (short)(buffer.Span[ii] + scalar); + buffer.Span[i] = (short)(buffer.Span[i] + scalar); } } } @@ -2828,9 +2828,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (short)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + buffer.Span[i] = (short)(buffer.Span[i] - right.Buffers[bb].Span[i]); } } } @@ -2839,9 +2839,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer column, short scal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (short)(buffer.Span[ii] - scalar); + buffer.Span[i] = (short)(buffer.Span[i] - scalar); } } } @@ -2850,9 +2850,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (short)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + buffer.Span[i] = (short)(buffer.Span[i] * right.Buffers[bb].Span[i]); } } } @@ -2861,9 +2861,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer column, short scal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (short)(buffer.Span[ii] * scalar); + buffer.Span[i] = (short)(buffer.Span[i] * scalar); } } } @@ -2872,9 +2872,9 @@ public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataF for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (short)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + buffer.Span[i] = (short)(buffer.Span[i] / right.Buffers[bb].Span[i]); } } } @@ -2883,9 +2883,9 @@ public void Divide(PrimitiveDataFrameColumnContainer column, short scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (short)(buffer.Span[ii] / scalar); + buffer.Span[i] = (short)(buffer.Span[i] / scalar); } } } @@ -2894,9 +2894,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataF for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (short)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + buffer.Span[i] = (short)(buffer.Span[i] % right.Buffers[bb].Span[i]); } } } @@ -2905,9 +2905,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer column, short scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (short)(buffer.Span[ii] % scalar); + buffer.Span[i] = (short)(buffer.Span[i] % scalar); } } } @@ -2916,9 +2916,9 @@ public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFram for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (short)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + buffer.Span[i] = (short)(buffer.Span[i] & right.Buffers[bb].Span[i]); } } } @@ -2927,9 +2927,9 @@ public void And(PrimitiveDataFrameColumnContainer column, short scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (short)(buffer.Span[ii] & scalar); + buffer.Span[i] = (short)(buffer.Span[i] & scalar); } } } @@ -2938,9 +2938,9 @@ public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrame for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (short)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + buffer.Span[i] = (short)(buffer.Span[i] | right.Buffers[bb].Span[i]); } } } @@ -2949,9 +2949,9 @@ public void Or(PrimitiveDataFrameColumnContainer column, short scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (short)(buffer.Span[ii] | scalar); + buffer.Span[i] = (short)(buffer.Span[i] | scalar); } } } @@ -2960,9 +2960,9 @@ public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFram for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (short)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + buffer.Span[i] = (short)(buffer.Span[i] ^ right.Buffers[bb].Span[i]); } } } @@ -2971,9 +2971,9 @@ public void Xor(PrimitiveDataFrameColumnContainer column, short scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (short)(buffer.Span[ii] ^ scalar); + buffer.Span[i] = (short)(buffer.Span[i] ^ scalar); } } } @@ -2982,9 +2982,9 @@ public void LeftShift(PrimitiveDataFrameColumnContainer column, int value for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (short)(buffer.Span[ii] << value); + buffer.Span[i] = (short)(buffer.Span[i] << value); } } } @@ -2993,9 +2993,9 @@ public void RightShift(PrimitiveDataFrameColumnContainer column, int valu for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (short)(buffer.Span[ii] >> value); + buffer.Span[i] = (short)(buffer.Span[i] >> value); } } } @@ -3004,9 +3004,9 @@ public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataF for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] == right.Buffers[bb].Span[i]); } } } @@ -3015,9 +3015,9 @@ public void Equals(PrimitiveDataFrameColumnContainer column, short scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == scalar); + ret[i] = (buffer.Span[i] == scalar); } } } @@ -3026,9 +3026,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDa for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] != right.Buffers[bb].Span[i]); } } } @@ -3037,9 +3037,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer column, short sca for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != scalar); + ret[i] = (buffer.Span[i] != scalar); } } } @@ -3048,9 +3048,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, Pr for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] >= right.Buffers[bb].Span[i]); } } } @@ -3059,9 +3059,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= scalar); + ret[i] = (buffer.Span[i] >= scalar); } } } @@ -3070,9 +3070,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, Primi for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] <= right.Buffers[bb].Span[i]); } } } @@ -3081,9 +3081,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, sho for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= scalar); + ret[i] = (buffer.Span[i] <= scalar); } } } @@ -3092,9 +3092,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer left, Primitive for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] > right.Buffers[bb].Span[i]); } } } @@ -3103,9 +3103,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer column, short s for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > scalar); + ret[i] = (buffer.Span[i] > scalar); } } } @@ -3114,9 +3114,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] < right.Buffers[bb].Span[i]); } } } @@ -3125,9 +3125,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer column, short scal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < scalar); + ret[i] = (buffer.Span[i] < scalar); } } } @@ -3139,9 +3139,9 @@ public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrame for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (uint)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + buffer.Span[i] = (uint)(buffer.Span[i] + right.Buffers[bb].Span[i]); } } } @@ -3150,9 +3150,9 @@ public void Add(PrimitiveDataFrameColumnContainer column, uint scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (uint)(buffer.Span[ii] + scalar); + buffer.Span[i] = (uint)(buffer.Span[i] + scalar); } } } @@ -3161,9 +3161,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveData for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (uint)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + buffer.Span[i] = (uint)(buffer.Span[i] - right.Buffers[bb].Span[i]); } } } @@ -3172,9 +3172,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer column, uint scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (uint)(buffer.Span[ii] - scalar); + buffer.Span[i] = (uint)(buffer.Span[i] - scalar); } } } @@ -3183,9 +3183,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveData for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (uint)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + buffer.Span[i] = (uint)(buffer.Span[i] * right.Buffers[bb].Span[i]); } } } @@ -3194,9 +3194,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer column, uint scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (uint)(buffer.Span[ii] * scalar); + buffer.Span[i] = (uint)(buffer.Span[i] * scalar); } } } @@ -3205,9 +3205,9 @@ public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataFr for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (uint)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + buffer.Span[i] = (uint)(buffer.Span[i] / right.Buffers[bb].Span[i]); } } } @@ -3216,9 +3216,9 @@ public void Divide(PrimitiveDataFrameColumnContainer column, uint scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (uint)(buffer.Span[ii] / scalar); + buffer.Span[i] = (uint)(buffer.Span[i] / scalar); } } } @@ -3227,9 +3227,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataFr for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (uint)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + buffer.Span[i] = (uint)(buffer.Span[i] % right.Buffers[bb].Span[i]); } } } @@ -3238,9 +3238,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer column, uint scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (uint)(buffer.Span[ii] % scalar); + buffer.Span[i] = (uint)(buffer.Span[i] % scalar); } } } @@ -3249,9 +3249,9 @@ public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrame for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (uint)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + buffer.Span[i] = (uint)(buffer.Span[i] & right.Buffers[bb].Span[i]); } } } @@ -3260,9 +3260,9 @@ public void And(PrimitiveDataFrameColumnContainer column, uint scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (uint)(buffer.Span[ii] & scalar); + buffer.Span[i] = (uint)(buffer.Span[i] & scalar); } } } @@ -3271,9 +3271,9 @@ public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrameC for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (uint)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + buffer.Span[i] = (uint)(buffer.Span[i] | right.Buffers[bb].Span[i]); } } } @@ -3282,9 +3282,9 @@ public void Or(PrimitiveDataFrameColumnContainer column, uint scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (uint)(buffer.Span[ii] | scalar); + buffer.Span[i] = (uint)(buffer.Span[i] | scalar); } } } @@ -3293,9 +3293,9 @@ public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrame for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (uint)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + buffer.Span[i] = (uint)(buffer.Span[i] ^ right.Buffers[bb].Span[i]); } } } @@ -3304,9 +3304,9 @@ public void Xor(PrimitiveDataFrameColumnContainer column, uint scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (uint)(buffer.Span[ii] ^ scalar); + buffer.Span[i] = (uint)(buffer.Span[i] ^ scalar); } } } @@ -3315,9 +3315,9 @@ public void LeftShift(PrimitiveDataFrameColumnContainer column, int value) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (uint)(buffer.Span[ii] << value); + buffer.Span[i] = (uint)(buffer.Span[i] << value); } } } @@ -3326,9 +3326,9 @@ public void RightShift(PrimitiveDataFrameColumnContainer column, int value for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (uint)(buffer.Span[ii] >> value); + buffer.Span[i] = (uint)(buffer.Span[i] >> value); } } } @@ -3337,9 +3337,9 @@ public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataFr for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] == right.Buffers[bb].Span[i]); } } } @@ -3348,9 +3348,9 @@ public void Equals(PrimitiveDataFrameColumnContainer column, uint scalar, for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == scalar); + ret[i] = (buffer.Span[i] == scalar); } } } @@ -3359,9 +3359,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] != right.Buffers[bb].Span[i]); } } } @@ -3370,9 +3370,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer column, uint scala for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != scalar); + ret[i] = (buffer.Span[i] != scalar); } } } @@ -3381,9 +3381,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, Pri for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] >= right.Buffers[bb].Span[i]); } } } @@ -3392,9 +3392,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, u for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= scalar); + ret[i] = (buffer.Span[i] >= scalar); } } } @@ -3403,9 +3403,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, Primit for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] <= right.Buffers[bb].Span[i]); } } } @@ -3414,9 +3414,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, uint for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= scalar); + ret[i] = (buffer.Span[i] <= scalar); } } } @@ -3425,9 +3425,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer left, PrimitiveD for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] > right.Buffers[bb].Span[i]); } } } @@ -3436,9 +3436,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer column, uint sca for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > scalar); + ret[i] = (buffer.Span[i] > scalar); } } } @@ -3447,9 +3447,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveData for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] < right.Buffers[bb].Span[i]); } } } @@ -3458,9 +3458,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer column, uint scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < scalar); + ret[i] = (buffer.Span[i] < scalar); } } } @@ -3472,9 +3472,9 @@ public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFram for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ulong)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + buffer.Span[i] = (ulong)(buffer.Span[i] + right.Buffers[bb].Span[i]); } } } @@ -3483,9 +3483,9 @@ public void Add(PrimitiveDataFrameColumnContainer column, ulong scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ulong)(buffer.Span[ii] + scalar); + buffer.Span[i] = (ulong)(buffer.Span[i] + scalar); } } } @@ -3494,9 +3494,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ulong)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + buffer.Span[i] = (ulong)(buffer.Span[i] - right.Buffers[bb].Span[i]); } } } @@ -3505,9 +3505,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer column, ulong scal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ulong)(buffer.Span[ii] - scalar); + buffer.Span[i] = (ulong)(buffer.Span[i] - scalar); } } } @@ -3516,9 +3516,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ulong)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + buffer.Span[i] = (ulong)(buffer.Span[i] * right.Buffers[bb].Span[i]); } } } @@ -3527,9 +3527,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer column, ulong scal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ulong)(buffer.Span[ii] * scalar); + buffer.Span[i] = (ulong)(buffer.Span[i] * scalar); } } } @@ -3538,9 +3538,9 @@ public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveDataF for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ulong)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + buffer.Span[i] = (ulong)(buffer.Span[i] / right.Buffers[bb].Span[i]); } } } @@ -3549,9 +3549,9 @@ public void Divide(PrimitiveDataFrameColumnContainer column, ulong scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ulong)(buffer.Span[ii] / scalar); + buffer.Span[i] = (ulong)(buffer.Span[i] / scalar); } } } @@ -3560,9 +3560,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveDataF for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ulong)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + buffer.Span[i] = (ulong)(buffer.Span[i] % right.Buffers[bb].Span[i]); } } } @@ -3571,9 +3571,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer column, ulong scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ulong)(buffer.Span[ii] % scalar); + buffer.Span[i] = (ulong)(buffer.Span[i] % scalar); } } } @@ -3582,9 +3582,9 @@ public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFram for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ulong)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + buffer.Span[i] = (ulong)(buffer.Span[i] & right.Buffers[bb].Span[i]); } } } @@ -3593,9 +3593,9 @@ public void And(PrimitiveDataFrameColumnContainer column, ulong scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ulong)(buffer.Span[ii] & scalar); + buffer.Span[i] = (ulong)(buffer.Span[i] & scalar); } } } @@ -3604,9 +3604,9 @@ public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFrame for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ulong)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + buffer.Span[i] = (ulong)(buffer.Span[i] | right.Buffers[bb].Span[i]); } } } @@ -3615,9 +3615,9 @@ public void Or(PrimitiveDataFrameColumnContainer column, ulong scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ulong)(buffer.Span[ii] | scalar); + buffer.Span[i] = (ulong)(buffer.Span[i] | scalar); } } } @@ -3626,9 +3626,9 @@ public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFram for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ulong)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + buffer.Span[i] = (ulong)(buffer.Span[i] ^ right.Buffers[bb].Span[i]); } } } @@ -3637,9 +3637,9 @@ public void Xor(PrimitiveDataFrameColumnContainer column, ulong scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ulong)(buffer.Span[ii] ^ scalar); + buffer.Span[i] = (ulong)(buffer.Span[i] ^ scalar); } } } @@ -3648,9 +3648,9 @@ public void LeftShift(PrimitiveDataFrameColumnContainer column, int value for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ulong)(buffer.Span[ii] << value); + buffer.Span[i] = (ulong)(buffer.Span[i] << value); } } } @@ -3659,9 +3659,9 @@ public void RightShift(PrimitiveDataFrameColumnContainer column, int valu for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ulong)(buffer.Span[ii] >> value); + buffer.Span[i] = (ulong)(buffer.Span[i] >> value); } } } @@ -3670,9 +3670,9 @@ public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveDataF for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] == right.Buffers[bb].Span[i]); } } } @@ -3681,9 +3681,9 @@ public void Equals(PrimitiveDataFrameColumnContainer column, ulong scalar for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == scalar); + ret[i] = (buffer.Span[i] == scalar); } } } @@ -3692,9 +3692,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveDa for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] != right.Buffers[bb].Span[i]); } } } @@ -3703,9 +3703,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer column, ulong sca for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != scalar); + ret[i] = (buffer.Span[i] != scalar); } } } @@ -3714,9 +3714,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, Pr for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] >= right.Buffers[bb].Span[i]); } } } @@ -3725,9 +3725,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= scalar); + ret[i] = (buffer.Span[i] >= scalar); } } } @@ -3736,9 +3736,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, Primi for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] <= right.Buffers[bb].Span[i]); } } } @@ -3747,9 +3747,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, ulo for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= scalar); + ret[i] = (buffer.Span[i] <= scalar); } } } @@ -3758,9 +3758,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer left, Primitive for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] > right.Buffers[bb].Span[i]); } } } @@ -3769,9 +3769,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer column, ulong s for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > scalar); + ret[i] = (buffer.Span[i] > scalar); } } } @@ -3780,9 +3780,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDat for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] < right.Buffers[bb].Span[i]); } } } @@ -3791,9 +3791,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer column, ulong scal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < scalar); + ret[i] = (buffer.Span[i] < scalar); } } } @@ -3805,9 +3805,9 @@ public void Add(PrimitiveDataFrameColumnContainer left, PrimitiveDataFra for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ushort)(buffer.Span[ii] + right.Buffers[bb].Span[ii]); + buffer.Span[i] = (ushort)(buffer.Span[i] + right.Buffers[bb].Span[i]); } } } @@ -3816,9 +3816,9 @@ public void Add(PrimitiveDataFrameColumnContainer column, ushort scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ushort)(buffer.Span[ii] + scalar); + buffer.Span[i] = (ushort)(buffer.Span[i] + scalar); } } } @@ -3827,9 +3827,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer left, PrimitiveDa for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ushort)(buffer.Span[ii] - right.Buffers[bb].Span[ii]); + buffer.Span[i] = (ushort)(buffer.Span[i] - right.Buffers[bb].Span[i]); } } } @@ -3838,9 +3838,9 @@ public void Subtract(PrimitiveDataFrameColumnContainer column, ushort sc for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ushort)(buffer.Span[ii] - scalar); + buffer.Span[i] = (ushort)(buffer.Span[i] - scalar); } } } @@ -3849,9 +3849,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer left, PrimitiveDa for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ushort)(buffer.Span[ii] * right.Buffers[bb].Span[ii]); + buffer.Span[i] = (ushort)(buffer.Span[i] * right.Buffers[bb].Span[i]); } } } @@ -3860,9 +3860,9 @@ public void Multiply(PrimitiveDataFrameColumnContainer column, ushort sc for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ushort)(buffer.Span[ii] * scalar); + buffer.Span[i] = (ushort)(buffer.Span[i] * scalar); } } } @@ -3871,9 +3871,9 @@ public void Divide(PrimitiveDataFrameColumnContainer left, PrimitiveData for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ushort)(buffer.Span[ii] / right.Buffers[bb].Span[ii]); + buffer.Span[i] = (ushort)(buffer.Span[i] / right.Buffers[bb].Span[i]); } } } @@ -3882,9 +3882,9 @@ public void Divide(PrimitiveDataFrameColumnContainer column, ushort scal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ushort)(buffer.Span[ii] / scalar); + buffer.Span[i] = (ushort)(buffer.Span[i] / scalar); } } } @@ -3893,9 +3893,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer left, PrimitiveData for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ushort)(buffer.Span[ii] % right.Buffers[bb].Span[ii]); + buffer.Span[i] = (ushort)(buffer.Span[i] % right.Buffers[bb].Span[i]); } } } @@ -3904,9 +3904,9 @@ public void Modulo(PrimitiveDataFrameColumnContainer column, ushort scal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ushort)(buffer.Span[ii] % scalar); + buffer.Span[i] = (ushort)(buffer.Span[i] % scalar); } } } @@ -3915,9 +3915,9 @@ public void And(PrimitiveDataFrameColumnContainer left, PrimitiveDataFra for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ushort)(buffer.Span[ii] & right.Buffers[bb].Span[ii]); + buffer.Span[i] = (ushort)(buffer.Span[i] & right.Buffers[bb].Span[i]); } } } @@ -3926,9 +3926,9 @@ public void And(PrimitiveDataFrameColumnContainer column, ushort scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ushort)(buffer.Span[ii] & scalar); + buffer.Span[i] = (ushort)(buffer.Span[i] & scalar); } } } @@ -3937,9 +3937,9 @@ public void Or(PrimitiveDataFrameColumnContainer left, PrimitiveDataFram for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ushort)(buffer.Span[ii] | right.Buffers[bb].Span[ii]); + buffer.Span[i] = (ushort)(buffer.Span[i] | right.Buffers[bb].Span[i]); } } } @@ -3948,9 +3948,9 @@ public void Or(PrimitiveDataFrameColumnContainer column, ushort scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ushort)(buffer.Span[ii] | scalar); + buffer.Span[i] = (ushort)(buffer.Span[i] | scalar); } } } @@ -3959,9 +3959,9 @@ public void Xor(PrimitiveDataFrameColumnContainer left, PrimitiveDataFra for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ushort)(buffer.Span[ii] ^ right.Buffers[bb].Span[ii]); + buffer.Span[i] = (ushort)(buffer.Span[i] ^ right.Buffers[bb].Span[i]); } } } @@ -3970,9 +3970,9 @@ public void Xor(PrimitiveDataFrameColumnContainer column, ushort scalar) for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ushort)(buffer.Span[ii] ^ scalar); + buffer.Span[i] = (ushort)(buffer.Span[i] ^ scalar); } } } @@ -3981,9 +3981,9 @@ public void LeftShift(PrimitiveDataFrameColumnContainer column, int valu for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ushort)(buffer.Span[ii] << value); + buffer.Span[i] = (ushort)(buffer.Span[i] << value); } } } @@ -3992,9 +3992,9 @@ public void RightShift(PrimitiveDataFrameColumnContainer column, int val for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - buffer.Span[ii] = (ushort)(buffer.Span[ii] >> value); + buffer.Span[i] = (ushort)(buffer.Span[i] >> value); } } } @@ -4003,9 +4003,9 @@ public void Equals(PrimitiveDataFrameColumnContainer left, PrimitiveData for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] == right.Buffers[bb].Span[i]); } } } @@ -4014,9 +4014,9 @@ public void Equals(PrimitiveDataFrameColumnContainer column, ushort scal for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] == scalar); + ret[i] = (buffer.Span[i] == scalar); } } } @@ -4025,9 +4025,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer left, PrimitiveD for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] != right.Buffers[bb].Span[i]); } } } @@ -4036,9 +4036,9 @@ public void NotEquals(PrimitiveDataFrameColumnContainer column, ushort s for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] != scalar); + ret[i] = (buffer.Span[i] != scalar); } } } @@ -4047,9 +4047,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer left, P for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] >= right.Buffers[bb].Span[i]); } } } @@ -4058,9 +4058,9 @@ public void GreaterThanOrEqual(PrimitiveDataFrameColumnContainer column, for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] >= scalar); + ret[i] = (buffer.Span[i] >= scalar); } } } @@ -4069,9 +4069,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer left, Prim for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] <= right.Buffers[bb].Span[i]); } } } @@ -4080,9 +4080,9 @@ public void LessThanOrEqual(PrimitiveDataFrameColumnContainer column, us for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] <= scalar); + ret[i] = (buffer.Span[i] <= scalar); } } } @@ -4091,9 +4091,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer left, Primitiv for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] > right.Buffers[bb].Span[i]); } } } @@ -4102,9 +4102,9 @@ public void GreaterThan(PrimitiveDataFrameColumnContainer column, ushort for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] > scalar); + ret[i] = (buffer.Span[i] > scalar); } } } @@ -4113,9 +4113,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer left, PrimitiveDa for (int bb = 0 ; bb < left.Buffers.Count; bb++) { var buffer = left.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < right.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] < right.Buffers[bb].Span[i]); } } } @@ -4124,9 +4124,9 @@ public void LessThan(PrimitiveDataFrameColumnContainer column, ushort sc for (int bb = 0 ; bb < column.Buffers.Count; bb++) { var buffer = column.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - ret[ii] = (buffer.Span[ii] < scalar); + ret[i] = (buffer.Span[i] < scalar); } } } diff --git a/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.tt b/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.tt index 02ea3dc3d8d..75d88971dfb 100644 --- a/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.tt +++ b/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.tt @@ -56,16 +56,16 @@ namespace Microsoft.Data for (int bb = 0 ; bb < <#= method.Op1Name #>.Buffers.Count; bb++) { var buffer = <#= method.Op1Name #>.Buffers[bb]; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { <# if (method.MethodType == MethodType.BinaryScalar || method.MethodType == MethodType.BinaryInt) { #> - buffer.Span[ii] = (<#=type.TypeName#>)(buffer.Span[ii] <#= method.Operator #> <#= method.Op2Name #>); + buffer.Span[i] = (<#=type.TypeName#>)(buffer.Span[i] <#= method.Operator #> <#= method.Op2Name #>); <# } else if (method.MethodType == MethodType.Binary) { #> - buffer.Span[ii] = (<#=type.TypeName#>)(buffer.Span[ii] <#= method.Operator #> <#= method.Op2Name #>.Buffers[bb].Span[ii]); + buffer.Span[i] = (<#=type.TypeName#>)(buffer.Span[i] <#= method.Operator #> <#= method.Op2Name #>.Buffers[bb].Span[i]); <# } else if (method.MethodType == MethodType.Comparison) { #> - ret[ii] = (buffer.Span[ii] <#= method.Operator #> <#= method.Op2Name #>.Buffers[bb].Span[ii]); + ret[i] = (buffer.Span[i] <#= method.Operator #> <#= method.Op2Name #>.Buffers[bb].Span[i]); <# } else if (method.MethodType == MethodType.ComparisonScalar) { #> - ret[ii] = (buffer.Span[ii] <#= method.Operator #> <#= method.Op2Name #>); + ret[i] = (buffer.Span[i] <#= method.Operator #> <#= method.Op2Name #>); <# } else {#> throw new NotImplementedException(); <# } #> diff --git a/src/Microsoft.Data/PrimitiveDataFrameColumnContainer.cs b/src/Microsoft.Data/PrimitiveDataFrameColumnContainer.cs index d539ac101e3..15b3be95987 100644 --- a/src/Microsoft.Data/PrimitiveDataFrameColumnContainer.cs +++ b/src/Microsoft.Data/PrimitiveDataFrameColumnContainer.cs @@ -112,7 +112,7 @@ public T this[long rowIndex] public override string ToString() { - StringBuilder sb = new StringBuilder(""); + StringBuilder sb = new StringBuilder(); foreach (var buffer in Buffers) { sb.Append(buffer.ToString()); @@ -134,9 +134,9 @@ public PrimitiveDataFrameColumnContainer Clone() ret.Buffers.Add(newBuffer); var span = buffer.Span; ret.Length += buffer.Length; - for (int ii = 0; ii < buffer.Length; ii++) + for (int i = 0; i < buffer.Length; i++) { - newBuffer.Append(span[ii]); + newBuffer.Append(span[i]); } } return ret; From 004fb10efb2f05896978c0f6b5fb0c0b02ac165c Mon Sep 17 00:00:00 2001 From: Prashanth Govindarajan Date: Wed, 17 Apr 2019 16:23:25 -0700 Subject: [PATCH 3/8] Address Dan's feedback --- src/Microsoft.Data/BaseDataFrameColumn.cs | 21 ++++++++++++++++- src/Microsoft.Data/DataFrame.cs | 23 ++++++++++--------- src/Microsoft.Data/DataFrameBuffer.cs | 16 +++++++++---- .../DataFrameColumnArithmeticTemplate.cs | 1 - ...ataFrameColumnArithmeticTemplate.ttinclude | 1 - src/Microsoft.Data/DataFrameTable.cs | 14 +++++++++-- .../PrimitiveDataFrameColumn.cs | 12 ++++++++++ 7 files changed, 68 insertions(+), 20 deletions(-) delete mode 100644 src/Microsoft.Data/DataFrameColumnArithmeticTemplate.cs diff --git a/src/Microsoft.Data/BaseDataFrameColumn.cs b/src/Microsoft.Data/BaseDataFrameColumn.cs index 5280c561f16..3aba1906109 100644 --- a/src/Microsoft.Data/BaseDataFrameColumn.cs +++ b/src/Microsoft.Data/BaseDataFrameColumn.cs @@ -8,6 +8,9 @@ namespace Microsoft.Data { + /// + /// The base column type. All APIs should have atleast a stub here first + /// public abstract class BaseDataFrameColumn { public BaseDataFrameColumn(string name, long length = 0) @@ -15,11 +18,27 @@ public BaseDataFrameColumn(string name, long length = 0) Length = length; Name = name; } - public long Length { get; protected set; } + + private long _length; + public long Length + { + get => _length; + protected set + { + if (value <= 0) + { + throw new ArgumentException(); + } + } + } + public long NullCount { get; protected set; } + public string Name; public virtual object this[long rowIndex] { get { throw new NotImplementedException(); } set { throw new NotImplementedException(); } } + public virtual object this[long startIndex, int length] { get { throw new NotImplementedException(); } } + } } diff --git a/src/Microsoft.Data/DataFrame.cs b/src/Microsoft.Data/DataFrame.cs index 3c081625457..12efbff28d2 100644 --- a/src/Microsoft.Data/DataFrame.cs +++ b/src/Microsoft.Data/DataFrame.cs @@ -8,43 +8,44 @@ namespace Microsoft.Data { /// - /// A DataFrame + /// A DataFrame to support indexing, binary operations, sorting, selection and other APIs. This will eventually also expose an IDataView for ML.NET /// public partial class DataFrame { - internal DataFrameTable _table; + private DataFrameTable _table; public DataFrame() { _table = new DataFrameTable(); } public long RowCount => _table.RowCount; + public int ColumnCount => _table.ColumnCount; + public IList Columns() { - var ret = new List(); + var ret = new List(ColumnCount); for (int i = 0; i < ColumnCount; i++) { ret.Add(_table.Column(i).Name); } return ret; } + public BaseDataFrameColumn Column(int index) => _table.Column(index); + public void InsertColumn(int columnIndex, BaseDataFrameColumn column) => _table.InsertColumn(columnIndex, column); + public void SetColumn(int columnIndex, BaseDataFrameColumn column) => _table.SetColumn(columnIndex, column); + public void RemoveColumn(int columnIndex) => _table.RemoveColumn(columnIndex); + public void RemoveColumn(string columnName) => _table.RemoveColumn(columnName); public object this[long rowIndex, int columnIndex] { - get - { - return _table.Column(columnIndex)[rowIndex]; - } - set - { - _table.Column(columnIndex)[rowIndex] = value; - } + get => _table.Column(columnIndex)[rowIndex]; + set => _table.Column(columnIndex)[rowIndex] = value; } #region Operators diff --git a/src/Microsoft.Data/DataFrameBuffer.cs b/src/Microsoft.Data/DataFrameBuffer.cs index b30711eee35..ac8aaac7558 100644 --- a/src/Microsoft.Data/DataFrameBuffer.cs +++ b/src/Microsoft.Data/DataFrameBuffer.cs @@ -6,14 +6,20 @@ using System.Collections.Generic; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; +using System.Text; namespace Microsoft.Data { + /// + /// A basic store to hold values in a DataFrame column. Supports wrapping with an ArrowBuffer + /// + /// public class DataFrameBuffer where T : struct { // TODO: Change this to Memory public Memory Memory { get; private set; } + private readonly int _size; private int Capacity => Memory.Length / _size; @@ -36,7 +42,6 @@ public DataFrameBuffer(int numberOfValues = 8) throw new ArgumentException($"{numberOfValues} exceeds buffer capacity", nameof(numberOfValues)); } Memory = new byte[numberOfValues * _size]; - Length = 0; } public void Append(T value) @@ -49,6 +54,7 @@ public void Append(T value) Span[Length] = value; if (Length < MaxCapacity) ++Length; } + // TODO: Implement Append(Range of values)? public void EnsureCapacity(int numberOfValues) { @@ -94,15 +100,17 @@ internal T this[int index] return true; } } + public override string ToString() { - string ret = ""; + StringBuilder sb = new StringBuilder(); Span span = Span; for (int i = 0; i < Length; i++) { - ret += span[i] + " "; + sb.Append(span[i]).Append(" "); } - return ret; + return sb.ToString(); } + } } diff --git a/src/Microsoft.Data/DataFrameColumnArithmeticTemplate.cs b/src/Microsoft.Data/DataFrameColumnArithmeticTemplate.cs deleted file mode 100644 index 5f282702bb0..00000000000 --- a/src/Microsoft.Data/DataFrameColumnArithmeticTemplate.cs +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/src/Microsoft.Data/DataFrameColumnArithmeticTemplate.ttinclude b/src/Microsoft.Data/DataFrameColumnArithmeticTemplate.ttinclude index 8a1fdca4e0b..00008039103 100644 --- a/src/Microsoft.Data/DataFrameColumnArithmeticTemplate.ttinclude +++ b/src/Microsoft.Data/DataFrameColumnArithmeticTemplate.ttinclude @@ -97,7 +97,6 @@ new MethodConfiguration("LessThan", MethodType.ComparisonScalar, "<", isNumeric:true), }; - public class MethodConfiguration { public MethodConfiguration(string methodName, MethodType methodType, string op = null, bool isNumeric = false, bool isBitwise = false) diff --git a/src/Microsoft.Data/DataFrameTable.cs b/src/Microsoft.Data/DataFrameTable.cs index 10f3666d34a..0a52a96c4cc 100644 --- a/src/Microsoft.Data/DataFrameTable.cs +++ b/src/Microsoft.Data/DataFrameTable.cs @@ -15,16 +15,19 @@ internal class DataFrameTable private IList _columns; private List _columnNames = new List(); - private Dictionary _columnNameToIndexDictionary = new Dictionary(); + + private Dictionary _columnNameToIndexDictionary = new Dictionary(StringComparer.Ordinal); public long RowCount { get; private set; } = 0; + public int ColumnCount { get; private set; } = 0; + public DataFrameTable() { _columns = new List(); } - public DataFrameTable(IList columns) + private DataFrameTable(IList columns) { columns = columns ?? throw new ArgumentNullException(nameof(columns)); _columns = columns; @@ -42,7 +45,9 @@ public DataFrameTable(IList columns) } public DataFrameTable(BaseDataFrameColumn column) : this(new List { column }) { } + public BaseDataFrameColumn Column(int columnIndex) => _columns[columnIndex]; + public IList GetRow(long rowIndex) { var ret = new List(); @@ -64,6 +69,7 @@ public void InsertColumn(int columnIndex, IEnumerable column, string colum BaseDataFrameColumn newColumn = new PrimitiveDataFrameColumn(columnName, column); InsertColumn(columnIndex, newColumn); } + public void InsertColumn(int columnIndex, BaseDataFrameColumn column) { column = column ?? throw new ArgumentNullException(nameof(column)); @@ -85,6 +91,7 @@ public void InsertColumn(int columnIndex, BaseDataFrameColumn column) _columns.Insert(columnIndex, column); ColumnCount++; } + public void SetColumn(int columnIndex, BaseDataFrameColumn column) { column = column ?? throw new ArgumentNullException(nameof(column)); @@ -105,6 +112,7 @@ public void SetColumn(int columnIndex, BaseDataFrameColumn column) _columnNameToIndexDictionary[column.Name] = columnIndex; _columns[columnIndex] = column; } + public void RemoveColumn(int columnIndex) { _columnNameToIndexDictionary.Remove(_columnNames[columnIndex]); @@ -112,6 +120,7 @@ public void RemoveColumn(int columnIndex) _columns.RemoveAt(columnIndex); ColumnCount--; } + public void RemoveColumn(string columnName) { int columnIndex = GetColumnIndex(columnName); @@ -129,5 +138,6 @@ public int GetColumnIndex(string columnName) } return -1; } + } } diff --git a/src/Microsoft.Data/PrimitiveDataFrameColumn.cs b/src/Microsoft.Data/PrimitiveDataFrameColumn.cs index 3f7432a94cf..ec0798aec5f 100644 --- a/src/Microsoft.Data/PrimitiveDataFrameColumn.cs +++ b/src/Microsoft.Data/PrimitiveDataFrameColumn.cs @@ -7,20 +7,28 @@ namespace Microsoft.Data { + /// + /// A column to hold primitive values such as int, float etc. Other value types are not really supported + /// + /// public class PrimitiveDataFrameColumn : BaseDataFrameColumn where T : struct { internal PrimitiveDataFrameColumnContainer _columnContainer; + public Type DataType = typeof(T); + internal PrimitiveDataFrameColumn(string name, PrimitiveDataFrameColumnContainer column) : base(name, column.Length) { _columnContainer = column; } + public PrimitiveDataFrameColumn(string name, IEnumerable values) : base(name) { _columnContainer = new PrimitiveDataFrameColumnContainer(values); Length = _columnContainer.Length; } + public PrimitiveDataFrameColumn(string name, bool isNullable = true) : base(name) { _columnContainer = new PrimitiveDataFrameColumnContainer(); @@ -49,11 +57,14 @@ public override object this[long rowIndex] _columnContainer[rowIndex] = (T)value; } } + public void Add(T value) => _columnContainer.Add(value); + public override string ToString() { return $"{Name}: {_columnContainer.ToString()}"; } + public PrimitiveDataFrameColumn Clone() { PrimitiveDataFrameColumnContainer newColumnContainer = _columnContainer.Clone(); @@ -65,5 +76,6 @@ internal PrimitiveDataFrameColumn CreateBoolColumnForCompareOps() PrimitiveDataFrameColumnContainer newColumnContainer = _columnContainer.CreateBoolContainerForCompareOps(); return new PrimitiveDataFrameColumn(Name, newColumnContainer); } + } } From 76d28b9a4f9cc73a14068c75bf87b77d958cae67 Mon Sep 17 00:00:00 2001 From: Prashanth Govindarajan Date: Wed, 17 Apr 2019 20:07:21 -0700 Subject: [PATCH 4/8] Address perf feedback --- src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.cs | 2 +- src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.tt | 2 +- src/Microsoft.Data/PrimitiveDataFrameColumnContainer.cs | 4 ++++ 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.cs b/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.cs index e799dd70a89..28b66b26315 100644 --- a/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.cs +++ b/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.cs @@ -106,7 +106,7 @@ public static IPrimitiveDataFrameColumnArithmetic GetArithmetic() { return (IPrimitiveDataFrameColumnArithmetic)new UShortArithmetic(); } - return null; + throw new NotSupportedException(); } } diff --git a/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.tt b/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.tt index 75d88971dfb..eda60513700 100644 --- a/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.tt +++ b/src/Microsoft.Data/PrimitiveDataFrameColumnArithmetic.tt @@ -40,7 +40,7 @@ namespace Microsoft.Data return (IPrimitiveDataFrameColumnArithmetic)new <#=type.ClassPrefix#>Arithmetic(); } <# } #> - return null; + throw new NotSupportedException(); } } diff --git a/src/Microsoft.Data/PrimitiveDataFrameColumnContainer.cs b/src/Microsoft.Data/PrimitiveDataFrameColumnContainer.cs index 15b3be95987..78790423292 100644 --- a/src/Microsoft.Data/PrimitiveDataFrameColumnContainer.cs +++ b/src/Microsoft.Data/PrimitiveDataFrameColumnContainer.cs @@ -41,6 +41,7 @@ public PrimitiveDataFrameColumnContainer(T[] values) Length++; } } + public PrimitiveDataFrameColumnContainer(IEnumerable values) { values = values ?? throw new ArgumentNullException(nameof(values)); @@ -60,7 +61,9 @@ public PrimitiveDataFrameColumnContainer(IEnumerable values) Length++; } } + public PrimitiveDataFrameColumnContainer() { } + public long Length; //TODO: public long NullCount => throw new NotImplementedException(); @@ -96,6 +99,7 @@ private int GetArrayContainingRowIndex(ref long rowIndex) return ret; } } + public T this[long rowIndex] { get From 2963c895de482138db10ebcda4c28109715dfffc Mon Sep 17 00:00:00 2001 From: Prashanth Govindarajan Date: Wed, 17 Apr 2019 20:32:28 -0700 Subject: [PATCH 5/8] Namespace change --- corefxlab.sln | 4 ++-- src/Microsoft.Data/DataFrameTable.cs | 13 ++++++------- ....Data.csproj => Microsoft.Data.DataFrame.csproj} | 0 ...csproj => Microsoft.Data.DataFrame.Tests.csproj} | 8 ++++---- 4 files changed, 12 insertions(+), 13 deletions(-) rename src/Microsoft.Data/{Microsoft.Data.csproj => Microsoft.Data.DataFrame.csproj} (100%) rename tests/Microsoft.Data.Tests/{Microsoft.Data.Tests.csproj => Microsoft.Data.DataFrame.Tests.csproj} (75%) diff --git a/corefxlab.sln b/corefxlab.sln index 1269f891525..d0ad37ae2b5 100644 --- a/corefxlab.sln +++ b/corefxlab.sln @@ -110,9 +110,9 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Numerics.Experimenta EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Numerics.Experimental.Tests", "tests\System.Numerics.Experimental.Tests\System.Numerics.Experimental.Tests.csproj", "{6411FD4E-0CDF-4478-9192-4411DC932314}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Data", "src\Microsoft.Data\Microsoft.Data.csproj", "{AD22AAD4-FCB0-4DB4-BC38-AB6ACD153899}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Data.DataFrame", "src\Microsoft.Data\Microsoft.Data.DataFrame.csproj", "{AD22AAD4-FCB0-4DB4-BC38-AB6ACD153899}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Data.Tests", "tests\Microsoft.Data.Tests\Microsoft.Data.Tests.csproj", "{485FC567-4AEC-4335-B767-283173F64C42}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Data.DataFrame.Tests", "tests\Microsoft.Data.Tests\Microsoft.Data.DataFrame.Tests.csproj", "{485FC567-4AEC-4335-B767-283173F64C42}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution diff --git a/src/Microsoft.Data/DataFrameTable.cs b/src/Microsoft.Data/DataFrameTable.cs index 0a52a96c4cc..6235adc7efe 100644 --- a/src/Microsoft.Data/DataFrameTable.cs +++ b/src/Microsoft.Data/DataFrameTable.cs @@ -18,9 +18,9 @@ internal class DataFrameTable private Dictionary _columnNameToIndexDictionary = new Dictionary(StringComparer.Ordinal); - public long RowCount { get; private set; } = 0; + public long RowCount { get; private set; } - public int ColumnCount { get; private set; } = 0; + public int ColumnCount { get; private set; } public DataFrameTable() { @@ -35,11 +35,10 @@ private DataFrameTable(IList columns) if (columns.Count > 0) { RowCount = columns[0].Length; - int cc = 0; - foreach (var column in columns) + for (var i = 0; i < columns.Count; i++) { - _columnNames.Add(column.Name); - _columnNameToIndexDictionary.Add(column.Name, cc++); + _columnNames.Add(columns[i].Name); + _columnNameToIndexDictionary.Add(columns[i].Name, i); } } } @@ -62,7 +61,7 @@ public void InsertColumn(int columnIndex, IEnumerable column, string colum where T : struct { column = column ?? throw new ArgumentNullException(nameof(column)); - if (columnIndex < 0 || columnIndex > _columns.Count) + if ((uint)columnIndex > _columns.Count) { throw new ArgumentException($"Invalid columnIndex {columnIndex} passed into Table.AddColumn"); } diff --git a/src/Microsoft.Data/Microsoft.Data.csproj b/src/Microsoft.Data/Microsoft.Data.DataFrame.csproj similarity index 100% rename from src/Microsoft.Data/Microsoft.Data.csproj rename to src/Microsoft.Data/Microsoft.Data.DataFrame.csproj diff --git a/tests/Microsoft.Data.Tests/Microsoft.Data.Tests.csproj b/tests/Microsoft.Data.Tests/Microsoft.Data.DataFrame.Tests.csproj similarity index 75% rename from tests/Microsoft.Data.Tests/Microsoft.Data.Tests.csproj rename to tests/Microsoft.Data.Tests/Microsoft.Data.DataFrame.Tests.csproj index 9b3a69c68af..33bd61b6d36 100644 --- a/tests/Microsoft.Data.Tests/Microsoft.Data.Tests.csproj +++ b/tests/Microsoft.Data.Tests/Microsoft.Data.DataFrame.Tests.csproj @@ -9,9 +9,9 @@ - - - - + + + + From 3d358b6afe4008f91e4f5424c24c0ece1cabfae7 Mon Sep 17 00:00:00 2001 From: Prashanth Govindarajan Date: Thu, 18 Apr 2019 09:57:08 -0700 Subject: [PATCH 6/8] sq --- src/Microsoft.Data/BaseDataFrameColumn.cs | 3 +- .../Microsoft.Data.DataFrame.csproj | 63 +++++++++++++++++++ 2 files changed, 65 insertions(+), 1 deletion(-) diff --git a/src/Microsoft.Data/BaseDataFrameColumn.cs b/src/Microsoft.Data/BaseDataFrameColumn.cs index 3aba1906109..22114e1a7cf 100644 --- a/src/Microsoft.Data/BaseDataFrameColumn.cs +++ b/src/Microsoft.Data/BaseDataFrameColumn.cs @@ -25,10 +25,11 @@ public long Length get => _length; protected set { - if (value <= 0) + if (value < 0) { throw new ArgumentException(); } + _length = value; } } diff --git a/src/Microsoft.Data/Microsoft.Data.DataFrame.csproj b/src/Microsoft.Data/Microsoft.Data.DataFrame.csproj index 8c77f8c470b..a9b25c53f31 100644 --- a/src/Microsoft.Data/Microsoft.Data.DataFrame.csproj +++ b/src/Microsoft.Data/Microsoft.Data.DataFrame.csproj @@ -12,10 +12,38 @@ + + TextTemplatingFileGenerator + BaseColumn.BinaryOperations.cs + + + TextTemplatingFileGenerator + BaseColumn.BinaryOperators.cs + TextTemplatingFileGenerator DataFrameBinaryOperations.cs + + TextTemplatingFileGenerator + DataFrameBinaryOperators.cs + + + TextTemplatingFileGenerator + DataFrameColumnArithmeticTemplate.cs + + + TextTemplatingFileGenerator + PrimitiveColumn.BinaryOperations.cs + + + TextTemplatingFileGenerator + PrimitiveColumnArithmetic.cs + + + TextTemplatingFileGenerator + PrimitiveColumnContainer.BinaryOperations.cs + TextTemplatingFileGenerator PrimitiveDataFrameColumnArithmetic.cs @@ -31,11 +59,46 @@ + + True + True + BaseColumn.BinaryOperations.tt + + + True + True + BaseColumn.BinaryOperators.tt + True True DataFrameBinaryOperations.tt + + True + True + DataFrameBinaryOperators.tt + + + True + True + DataFrameColumnArithmeticTemplate.ttinclude + + + True + True + PrimitiveColumn.BinaryOperations.tt + + + True + True + PrimitiveColumnArithmetic.tt + + + True + True + PrimitiveColumnContainer.BinaryOperations.tt + True True From 1c166251c12f550aa587d6778441dbf92e75fa76 Mon Sep 17 00:00:00 2001 From: Prashanth Govindarajan Date: Thu, 18 Apr 2019 16:27:38 -0700 Subject: [PATCH 7/8] More feedback --- src/Microsoft.Data/BaseDataFrameColumn.cs | 6 +----- src/Microsoft.Data/DataFrame.cs | 15 +++++++++------ .../DataFrameColumnArithmeticTemplate.cs | 1 + src/Microsoft.Data/DataFrameTable.cs | 6 +++--- tests/Microsoft.Data.Tests/DataFrameTests.cs | 4 ++-- .../Microsoft.Data.DataFrame.Tests.csproj | 2 +- 6 files changed, 17 insertions(+), 17 deletions(-) create mode 100644 src/Microsoft.Data/DataFrameColumnArithmeticTemplate.cs diff --git a/src/Microsoft.Data/BaseDataFrameColumn.cs b/src/Microsoft.Data/BaseDataFrameColumn.cs index 22114e1a7cf..da1a6d38448 100644 --- a/src/Microsoft.Data/BaseDataFrameColumn.cs +++ b/src/Microsoft.Data/BaseDataFrameColumn.cs @@ -25,10 +25,7 @@ public long Length get => _length; protected set { - if (value < 0) - { - throw new ArgumentException(); - } + if (value < 0) throw new ArgumentOutOfRangeException(); _length = value; } } @@ -40,6 +37,5 @@ protected set public virtual object this[long rowIndex] { get { throw new NotImplementedException(); } set { throw new NotImplementedException(); } } public virtual object this[long startIndex, int length] { get { throw new NotImplementedException(); } } - } } diff --git a/src/Microsoft.Data/DataFrame.cs b/src/Microsoft.Data/DataFrame.cs index 12efbff28d2..eaadb29314d 100644 --- a/src/Microsoft.Data/DataFrame.cs +++ b/src/Microsoft.Data/DataFrame.cs @@ -12,7 +12,7 @@ namespace Microsoft.Data /// public partial class DataFrame { - private DataFrameTable _table; + private readonly DataFrameTable _table; public DataFrame() { _table = new DataFrameTable(); @@ -22,14 +22,17 @@ public DataFrame() public int ColumnCount => _table.ColumnCount; - public IList Columns() + public IList Columns { - var ret = new List(ColumnCount); - for (int i = 0; i < ColumnCount; i++) + get { - ret.Add(_table.Column(i).Name); + var ret = new List(ColumnCount); + for (int i = 0; i < ColumnCount; i++) + { + ret.Add(_table.Column(i).Name); + } + return ret; } - return ret; } public BaseDataFrameColumn Column(int index) => _table.Column(index); diff --git a/src/Microsoft.Data/DataFrameColumnArithmeticTemplate.cs b/src/Microsoft.Data/DataFrameColumnArithmeticTemplate.cs new file mode 100644 index 00000000000..5f282702bb0 --- /dev/null +++ b/src/Microsoft.Data/DataFrameColumnArithmeticTemplate.cs @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/src/Microsoft.Data/DataFrameTable.cs b/src/Microsoft.Data/DataFrameTable.cs index 6235adc7efe..6eebbbf1628 100644 --- a/src/Microsoft.Data/DataFrameTable.cs +++ b/src/Microsoft.Data/DataFrameTable.cs @@ -72,7 +72,7 @@ public void InsertColumn(int columnIndex, IEnumerable column, string colum public void InsertColumn(int columnIndex, BaseDataFrameColumn column) { column = column ?? throw new ArgumentNullException(nameof(column)); - if (columnIndex < 0 || columnIndex > _columns.Count) + if ((uint)columnIndex > _columns.Count) { throw new ArgumentException($"Invalid columnIndex {columnIndex} passed into Table.AddColumn"); } @@ -94,7 +94,7 @@ public void InsertColumn(int columnIndex, BaseDataFrameColumn column) public void SetColumn(int columnIndex, BaseDataFrameColumn column) { column = column ?? throw new ArgumentNullException(nameof(column)); - if (columnIndex < 0 || columnIndex >= ColumnCount) + if ((uint)columnIndex >= ColumnCount) { throw new ArgumentException($"Invalid columnIndex {columnIndex} passed in to Table.SetColumn"); } @@ -131,7 +131,7 @@ public void RemoveColumn(string columnName) public int GetColumnIndex(string columnName) { - if (_columnNameToIndexDictionary.TryGetValue(columnName, out int columnIndex) ) + if (_columnNameToIndexDictionary.TryGetValue(columnName, out int columnIndex)) { return columnIndex; } diff --git a/tests/Microsoft.Data.Tests/DataFrameTests.cs b/tests/Microsoft.Data.Tests/DataFrameTests.cs index 0d536e09bcc..644c6da54e1 100644 --- a/tests/Microsoft.Data.Tests/DataFrameTests.cs +++ b/tests/Microsoft.Data.Tests/DataFrameTests.cs @@ -27,8 +27,8 @@ public void TestIndexer() var foo = dataFrame[0, 0]; Assert.Equal(0, dataFrame[0, 0]); Assert.Equal(11, dataFrame[1, 1]); - Assert.Equal(2, dataFrame.Columns().Count); - Assert.Equal("Int1", dataFrame.Columns()[0]); + Assert.Equal(2, dataFrame.Columns.Count); + Assert.Equal("Int1", dataFrame.Columns[0]); var headList = dataFrame.Head(5); Assert.Equal(14, (int)headList[4][1]); diff --git a/tests/Microsoft.Data.Tests/Microsoft.Data.DataFrame.Tests.csproj b/tests/Microsoft.Data.Tests/Microsoft.Data.DataFrame.Tests.csproj index 33bd61b6d36..baf8ef446f2 100644 --- a/tests/Microsoft.Data.Tests/Microsoft.Data.DataFrame.Tests.csproj +++ b/tests/Microsoft.Data.Tests/Microsoft.Data.DataFrame.Tests.csproj @@ -1,7 +1,7 @@  - netcoreapp2.2 + netcoreapp3.0 From 00ee04daa4b5f4ad252a3473877c9eb3046fe71f Mon Sep 17 00:00:00 2001 From: Prashanth Govindarajan Date: Fri, 19 Apr 2019 09:48:29 -0700 Subject: [PATCH 8/8] sq --- src/Microsoft.Data/Microsoft.Data.DataFrame.csproj | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Microsoft.Data/Microsoft.Data.DataFrame.csproj b/src/Microsoft.Data/Microsoft.Data.DataFrame.csproj index a9b25c53f31..66fedd2b7a7 100644 --- a/src/Microsoft.Data/Microsoft.Data.DataFrame.csproj +++ b/src/Microsoft.Data/Microsoft.Data.DataFrame.csproj @@ -1,7 +1,7 @@  - netcoreapp2.2 + netstandard2.0