From 4c799ab1c881de54328fdafbfcfc5352bd727e89 Mon Sep 17 00:00:00 2001 From: Jake <31937616+JakeRadMSFT@users.noreply.github.com> Date: Tue, 27 Jun 2023 17:02:56 -0700 Subject: [PATCH 01/18] Update build templates to handle feature branches (#6744) * Update build templates * Update build templates to include all releases/* and feature/* * Update releases to release * Update triggers for PR Validation Build * Add triggers for Code Coverage --- .vsts-dotnet-ci.yml | 14 ++++++++++++++ build/.night-build.yml | 5 ++--- build/.outer-loop-build.yml | 5 ++--- build/codecoverage-ci.yml | 14 ++++++++++++++ 4 files changed, 32 insertions(+), 6 deletions(-) diff --git a/.vsts-dotnet-ci.yml b/.vsts-dotnet-ci.yml index 2b058953eb..846f15f004 100644 --- a/.vsts-dotnet-ci.yml +++ b/.vsts-dotnet-ci.yml @@ -2,6 +2,20 @@ # ML.NET's PR validation build ################################################################################ +pr: + branches: + include: + - main + - feature/* + - release/* + +trigger: + branches: + include: + - main + - feature/* + - release/* + resources: containers: - container: CentosContainer diff --git a/build/.night-build.yml b/build/.night-build.yml index 7559b99ff2..5ab9ebe9a6 100644 --- a/build/.night-build.yml +++ b/build/.night-build.yml @@ -15,9 +15,8 @@ schedules: branches: include: - main - - releases/1.6.0 - - features/automl - - features/integrationPackage + - feature/* + - release/* always: true resources: diff --git a/build/.outer-loop-build.yml b/build/.outer-loop-build.yml index be125bfd76..c159d4d0b6 100644 --- a/build/.outer-loop-build.yml +++ b/build/.outer-loop-build.yml @@ -15,9 +15,8 @@ schedules: branches: include: - main - - releases/1.6.0 - - features/automl - - features/integrationPackage + - feature/* + - release/* always: true diff --git a/build/codecoverage-ci.yml b/build/codecoverage-ci.yml index 2d0d082c23..04422e73c8 100644 --- a/build/codecoverage-ci.yml +++ b/build/codecoverage-ci.yml @@ -2,6 +2,20 @@ # ML.NET's Code Coverage validation build ################################################################################ +pr: + branches: + include: + - main + - feature/* + - release/* + +trigger: + branches: + include: + - main + - feature/* + - release/* + jobs: - template: /build/ci/job-template.yml parameters: From 443ceb936ef71f52f255562c084e340cba5f1d4d Mon Sep 17 00:00:00 2001 From: Aleksei Smirnov Date: Thu, 6 Jul 2023 22:15:46 +0300 Subject: [PATCH 02/18] Add missing implementation for datetime relevant arrow type into dataframe (#6675) * Add missing implementation for datetime relevant arrow type * Return required usage --- eng/Versions.props | 2 +- .../DataFrame.Arrow.cs | 15 ++++- src/Microsoft.Data.Analysis/DataFrame.IO.cs | 2 +- .../PrimitiveColumnContainer.cs | 12 ---- .../PrimitiveDataFrameColumn.cs | 57 ++++++++++++++----- .../ArrowIntegrationTests.cs | 1 + .../DataFrame.IOTests.cs | 2 +- 7 files changed, 60 insertions(+), 31 deletions(-) diff --git a/eng/Versions.props b/eng/Versions.props index 902cc3dab3..d13d42aadc 100644 --- a/eng/Versions.props +++ b/eng/Versions.props @@ -30,7 +30,7 @@ 6.0.1 4.7.1 - 2.0.0 + 11.0.0 3.19.6 2.3.1 3.3.0 diff --git a/src/Microsoft.Data.Analysis/DataFrame.Arrow.cs b/src/Microsoft.Data.Analysis/DataFrame.Arrow.cs index dc5be46421..2d67b9ee78 100644 --- a/src/Microsoft.Data.Analysis/DataFrame.Arrow.cs +++ b/src/Microsoft.Data.Analysis/DataFrame.Arrow.cs @@ -101,10 +101,18 @@ private static void AppendDataFrameColumnFromArrowArray(Field field, IArrowArray AppendDataFrameColumnFromArrowArray(fieldsEnumerator.Current, structArrayEnumerator.Current, ret, field.Name + "_"); } break; - case ArrowTypeId.Decimal: + case ArrowTypeId.Date64: + Date64Array arrowDate64Array = (Date64Array)arrowArray; + dataFrameColumn = new DateTimeDataFrameColumn(fieldName, arrowDate64Array.Data.Length); + for (int i = 0; i < arrowDate64Array.Data.Length; i++) + { + dataFrameColumn[i] = arrowDate64Array.GetDateTime(i); + } + break; + case ArrowTypeId.Decimal128: + case ArrowTypeId.Decimal256: case ArrowTypeId.Binary: case ArrowTypeId.Date32: - case ArrowTypeId.Date64: case ArrowTypeId.Dictionary: case ArrowTypeId.FixedSizedBinary: case ArrowTypeId.HalfFloat: @@ -114,6 +122,7 @@ private static void AppendDataFrameColumnFromArrowArray(Field field, IArrowArray case ArrowTypeId.Null: case ArrowTypeId.Time32: case ArrowTypeId.Time64: + case ArrowTypeId.Timestamp: default: throw new NotImplementedException($"{fieldType.Name}"); } @@ -145,7 +154,7 @@ public static DataFrame FromArrowRecordBatch(RecordBatch recordBatch) } /// - /// Returns an without copying data + /// Returns an mostly without copying data /// public IEnumerable ToArrowRecordBatches() { diff --git a/src/Microsoft.Data.Analysis/DataFrame.IO.cs b/src/Microsoft.Data.Analysis/DataFrame.IO.cs index e525624998..4a57397588 100644 --- a/src/Microsoft.Data.Analysis/DataFrame.IO.cs +++ b/src/Microsoft.Data.Analysis/DataFrame.IO.cs @@ -336,7 +336,7 @@ private static DataFrameColumn CreateColumn(Type kind, string columnName) } else if (kind == typeof(DateTime)) { - ret = new PrimitiveDataFrameColumn(columnName); + ret = new DateTimeDataFrameColumn(columnName); } else { diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs index 830440445e..022a6cdfe4 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs @@ -374,18 +374,6 @@ internal int MaxRecordBatchLength(long startIndex) return Buffers[arrayIndex].Length - (int)startIndex; } - internal ReadOnlyMemory GetValueBuffer(long startIndex) - { - int arrayIndex = GetArrayContainingRowIndex(startIndex); - return Buffers[arrayIndex].ReadOnlyBuffer; - } - - internal ReadOnlyMemory GetNullBuffer(long startIndex) - { - int arrayIndex = GetArrayContainingRowIndex(startIndex); - return NullBitMapBuffers[arrayIndex].ReadOnlyBuffer; - } - public IReadOnlyList this[long startIndex, int length] { get diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs index 531573c73d..4696244e2a 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs @@ -6,6 +6,7 @@ using System.Collections; using System.Collections.Generic; using System.Diagnostics; +using System.Runtime.InteropServices; using Apache.Arrow; using Apache.Arrow.Types; using Microsoft.ML; @@ -103,6 +104,8 @@ private IArrowType GetArrowType() return UInt64Type.Default; else if (typeof(T) == typeof(ushort)) return UInt16Type.Default; + else if (typeof(T) == typeof(DateTime)) + return Date64Type.Default; else throw new NotImplementedException(nameof(T)); } @@ -126,36 +129,64 @@ protected internal override Apache.Arrow.Array ToArrowArray(long startIndex, int { int arrayIndex = numberOfRows == 0 ? 0 : _columnContainer.GetArrayContainingRowIndex(startIndex); int offset = (int)(startIndex - arrayIndex * ReadOnlyDataFrameBuffer.MaxCapacity); + if (numberOfRows != 0 && numberOfRows > _columnContainer.Buffers[arrayIndex].Length - offset) { throw new ArgumentException(Strings.SpansMultipleBuffers, nameof(numberOfRows)); } - ArrowBuffer valueBuffer = numberOfRows == 0 ? ArrowBuffer.Empty : new ArrowBuffer(_columnContainer.GetValueBuffer(startIndex)); - ArrowBuffer nullBuffer = numberOfRows == 0 ? ArrowBuffer.Empty : new ArrowBuffer(_columnContainer.GetNullBuffer(startIndex)); + int nullCount = GetNullCount(startIndex, numberOfRows); + + //DateTime requires convertion + if (this.DataType == typeof(DateTime)) + { + if (numberOfRows == 0) + return new Date64Array(ArrowBuffer.Empty, ArrowBuffer.Empty, numberOfRows, nullCount, offset); + + ReadOnlyDataFrameBuffer valueBuffer = (numberOfRows == 0) ? null : _columnContainer.Buffers[arrayIndex]; + ReadOnlyDataFrameBuffer nullBuffer = (numberOfRows == 0) ? null : _columnContainer.NullBitMapBuffers[arrayIndex]; + + ReadOnlySpan valueSpan = MemoryMarshal.Cast(valueBuffer.ReadOnlySpan); + Date64Array.Builder builder = new Date64Array.Builder().Reserve(valueBuffer.Length); + + for (int i = 0; i < valueBuffer.Length; i++) + { + if (BitUtility.GetBit(nullBuffer.ReadOnlySpan, i)) + builder.Append(valueSpan[i]); + else + builder.AppendNull(); + } + + return builder.Build(); + } + + //No convertion + ArrowBuffer arrowValueBuffer = numberOfRows == 0 ? ArrowBuffer.Empty : new ArrowBuffer(_columnContainer.Buffers[arrayIndex].ReadOnlyBuffer); + ArrowBuffer arrowNullBuffer = numberOfRows == 0 ? ArrowBuffer.Empty : new ArrowBuffer(_columnContainer.NullBitMapBuffers[arrayIndex].ReadOnlyBuffer); + Type type = this.DataType; if (type == typeof(bool)) - return new BooleanArray(valueBuffer, nullBuffer, numberOfRows, nullCount, offset); + return new BooleanArray(arrowValueBuffer, arrowNullBuffer, numberOfRows, nullCount, offset); else if (type == typeof(double)) - return new DoubleArray(valueBuffer, nullBuffer, numberOfRows, nullCount, offset); + return new DoubleArray(arrowValueBuffer, arrowNullBuffer, numberOfRows, nullCount, offset); else if (type == typeof(float)) - return new FloatArray(valueBuffer, nullBuffer, numberOfRows, nullCount, offset); + return new FloatArray(arrowValueBuffer, arrowNullBuffer, numberOfRows, nullCount, offset); else if (type == typeof(int)) - return new Int32Array(valueBuffer, nullBuffer, numberOfRows, nullCount, offset); + return new Int32Array(arrowValueBuffer, arrowNullBuffer, numberOfRows, nullCount, offset); else if (type == typeof(long)) - return new Int64Array(valueBuffer, nullBuffer, numberOfRows, nullCount, offset); + return new Int64Array(arrowValueBuffer, arrowNullBuffer, numberOfRows, nullCount, offset); else if (type == typeof(sbyte)) - return new Int8Array(valueBuffer, nullBuffer, numberOfRows, nullCount, offset); + return new Int8Array(arrowValueBuffer, arrowNullBuffer, numberOfRows, nullCount, offset); else if (type == typeof(short)) - return new Int16Array(valueBuffer, nullBuffer, numberOfRows, nullCount, offset); + return new Int16Array(arrowValueBuffer, arrowNullBuffer, numberOfRows, nullCount, offset); else if (type == typeof(uint)) - return new UInt32Array(valueBuffer, nullBuffer, numberOfRows, nullCount, offset); + return new UInt32Array(arrowValueBuffer, arrowNullBuffer, numberOfRows, nullCount, offset); else if (type == typeof(ulong)) - return new UInt64Array(valueBuffer, nullBuffer, numberOfRows, nullCount, offset); + return new UInt64Array(arrowValueBuffer, arrowNullBuffer, numberOfRows, nullCount, offset); else if (type == typeof(ushort)) - return new UInt16Array(valueBuffer, nullBuffer, numberOfRows, nullCount, offset); + return new UInt16Array(arrowValueBuffer, arrowNullBuffer, numberOfRows, nullCount, offset); else if (type == typeof(byte)) - return new UInt8Array(valueBuffer, nullBuffer, numberOfRows, nullCount, offset); + return new UInt8Array(arrowValueBuffer, arrowNullBuffer, numberOfRows, nullCount, offset); else throw new NotImplementedException(type.ToString()); } diff --git a/test/Microsoft.Data.Analysis.Tests/ArrowIntegrationTests.cs b/test/Microsoft.Data.Analysis.Tests/ArrowIntegrationTests.cs index dacf43a8db..185ab835bb 100644 --- a/test/Microsoft.Data.Analysis.Tests/ArrowIntegrationTests.cs +++ b/test/Microsoft.Data.Analysis.Tests/ArrowIntegrationTests.cs @@ -48,6 +48,7 @@ public void TestArrowIntegration() .Append("ULongColumn", false, new UInt64Array.Builder().AppendRange(Enumerable.Repeat((ulong)1, 10)).Build()) .Append("ByteColumn", false, new Int8Array.Builder().AppendRange(Enumerable.Repeat((sbyte)1, 10)).Build()) .Append("UByteColumn", false, new UInt8Array.Builder().AppendRange(Enumerable.Repeat((byte)1, 10)).Build()) + .Append("Date64Column", false, new Date64Array.Builder().AppendRange(Enumerable.Repeat(DateTime.Now, 10)).Build()) .Build(); DataFrame df = DataFrame.FromArrowRecordBatch(originalBatch); diff --git a/test/Microsoft.Data.Analysis.Tests/DataFrame.IOTests.cs b/test/Microsoft.Data.Analysis.Tests/DataFrame.IOTests.cs index 398e849907..09e95bcae1 100644 --- a/test/Microsoft.Data.Analysis.Tests/DataFrame.IOTests.cs +++ b/test/Microsoft.Data.Analysis.Tests/DataFrame.IOTests.cs @@ -102,7 +102,7 @@ internal static void VerifyColumnTypes(DataFrame df, bool testArrowStringColumn } else if (dataType == typeof(DateTime)) { - Assert.IsType>(column); + Assert.IsType(column); } else { From 53c0f269d6d3bab9d50de6c69bf1ff408049af65 Mon Sep 17 00:00:00 2001 From: Aleksei Smirnov Date: Thu, 6 Jul 2023 22:17:20 +0300 Subject: [PATCH 03/18] Fix the behavior or column SetName method (#6676) * Fix the behavior or column SetName method * Fix stack overflow exception * Fix merge issues --------- Co-authored-by: Michael Sharp <51342856+michaelgsharp@users.noreply.github.com> --- src/Microsoft.Data.Analysis/DataFrame.Join.cs | 2 +- src/Microsoft.Data.Analysis/DataFrame.cs | 4 +- .../DataFrameColumn.cs | 42 +++++++++++++++---- .../DataFrameColumnCollection.cs | 23 +++++++++- .../DataFrameTests.cs | 38 +++++++++++++++++ 5 files changed, 96 insertions(+), 13 deletions(-) diff --git a/src/Microsoft.Data.Analysis/DataFrame.Join.cs b/src/Microsoft.Data.Analysis/DataFrame.Join.cs index 79291a691e..fe4b44e0d5 100644 --- a/src/Microsoft.Data.Analysis/DataFrame.Join.cs +++ b/src/Microsoft.Data.Analysis/DataFrame.Join.cs @@ -30,7 +30,7 @@ private void SetSuffixForDuplicatedColumnNames(DataFrame dataFrame, DataFrameCol { // Pre-existing column. Change name DataFrameColumn existingColumn = dataFrame.Columns[index]; - dataFrame._columnCollection.SetColumnName(existingColumn, existingColumn.Name + leftSuffix); + existingColumn.SetName(existingColumn.Name + leftSuffix); column.SetName(column.Name + rightSuffix); index = dataFrame._columnCollection.IndexOf(column.Name); } diff --git a/src/Microsoft.Data.Analysis/DataFrame.cs b/src/Microsoft.Data.Analysis/DataFrame.cs index 6c24476549..78d453d44a 100644 --- a/src/Microsoft.Data.Analysis/DataFrame.cs +++ b/src/Microsoft.Data.Analysis/DataFrame.cs @@ -301,7 +301,7 @@ public DataFrame AddPrefix(string prefix, bool inPlace = false) for (int i = 0; i < df.Columns.Count; i++) { DataFrameColumn column = df.Columns[i]; - df._columnCollection.SetColumnName(column, prefix + column.Name); + column.SetName(prefix + column.Name); df.OnColumnsChanged(); } return df; @@ -316,7 +316,7 @@ public DataFrame AddSuffix(string suffix, bool inPlace = false) for (int i = 0; i < df.Columns.Count; i++) { DataFrameColumn column = df.Columns[i]; - df._columnCollection.SetColumnName(column, column.Name + suffix); + column.SetName(column.Name + suffix); df.OnColumnsChanged(); } return df; diff --git a/src/Microsoft.Data.Analysis/DataFrameColumn.cs b/src/Microsoft.Data.Analysis/DataFrameColumn.cs index 636d7a8db1..d978dc69c3 100644 --- a/src/Microsoft.Data.Analysis/DataFrameColumn.cs +++ b/src/Microsoft.Data.Analysis/DataFrameColumn.cs @@ -84,6 +84,26 @@ protected set } } + // List of ColumnCollections that owns the column + // Current API allows column to be added into multiple dataframes, that's why the list is needed + private readonly List _ownerColumnCollections = new(); + + internal void AddOwner(DataFrameColumnCollection columCollection) + { + if (!_ownerColumnCollections.Contains(columCollection)) + { + _ownerColumnCollections.Add(columCollection); + } + } + + internal void RemoveOwner(DataFrameColumnCollection columCollection) + { + if (_ownerColumnCollections.Contains(columCollection)) + { + _ownerColumnCollections.Remove(columCollection); + } + } + /// /// The number of values in this column. /// @@ -95,24 +115,30 @@ public abstract long NullCount private string _name; /// - /// The name of this column. + /// The column name. /// public string Name => _name; /// - /// Updates the name of this column. + /// Updates the column name. /// /// The new name. - /// If passed in, update the column name in - public void SetName(string newName, DataFrame dataFrame = null) + public void SetName(string newName) { - if (!(dataFrame is null)) - { - dataFrame.Columns.SetColumnName(this, newName); - } + foreach (var owner in _ownerColumnCollections) + owner.UpdateColumnNameMetadata(this, newName); + _name = newName; } + /// + /// Updates the name of this column. + /// + /// The new name. + /// Ignored (for backward compatibility) + [Obsolete] + public void SetName(string newName, DataFrame dataFrame) => SetName(newName); + /// /// The type of data this column holds. /// diff --git a/src/Microsoft.Data.Analysis/DataFrameColumnCollection.cs b/src/Microsoft.Data.Analysis/DataFrameColumnCollection.cs index bad2a42f95..6dce481588 100644 --- a/src/Microsoft.Data.Analysis/DataFrameColumnCollection.cs +++ b/src/Microsoft.Data.Analysis/DataFrameColumnCollection.cs @@ -38,11 +38,23 @@ internal IReadOnlyList GetColumnNames() return ret; } + public void RenameColumn(string currentName, string newName) + { + var column = this[currentName]; + column.SetName(newName); + } + + [Obsolete] public void SetColumnName(DataFrameColumn column, string newName) + { + column.SetName(newName); + } + + //Updates column's metadata (is used as a callback from Column class) + internal void UpdateColumnNameMetadata(DataFrameColumn column, string newName) { string currentName = column.Name; int currentIndex = _columnNameToIndexDictionary[currentName]; - column.SetName(newName); _columnNameToIndexDictionary.Remove(currentName); _columnNameToIndexDictionary.Add(newName, currentIndex); ColumnsChanged?.Invoke(); @@ -75,6 +87,8 @@ protected override void InsertItem(int columnIndex, DataFrameColumn column) throw new ArgumentException(string.Format(Strings.DuplicateColumnName, column.Name), nameof(column)); } + column.AddOwner(this); + RowCount = column.Length; _columnNameToIndexDictionary[column.Name] = columnIndex; @@ -98,9 +112,13 @@ protected override void SetItem(int columnIndex, DataFrameColumn column) { throw new ArgumentException(string.Format(Strings.DuplicateColumnName, column.Name), nameof(column)); } + _columnNameToIndexDictionary.Remove(this[columnIndex].Name); _columnNameToIndexDictionary[column.Name] = columnIndex; + + this[columnIndex].RemoveOwner(this); base.SetItem(columnIndex, column); + ColumnsChanged?.Invoke(); } @@ -111,6 +129,8 @@ protected override void RemoveItem(int columnIndex) { _columnNameToIndexDictionary[this[i].Name]--; } + + this[columnIndex].RemoveOwner(this); base.RemoveItem(columnIndex); //Reset RowCount if the last column was removed and dataframe is empty @@ -474,6 +494,5 @@ public UInt16DataFrameColumn GetUInt16Column(string name) throw new ArgumentException(string.Format(Strings.BadColumnCast, column.DataType, typeof(UInt16))); } - } } diff --git a/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs b/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs index ec93aae4d5..859eb508ef 100644 --- a/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs +++ b/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs @@ -388,6 +388,44 @@ public void ClearColumnsTests() Assert.Equal(0, dataFrame.Columns.LongCount()); } + [Fact] + public void RenameColumnWithSetNameTests() + { + StringDataFrameColumn city = new StringDataFrameColumn("City", new string[] { "London", "Berlin" }); + PrimitiveDataFrameColumn temp = new PrimitiveDataFrameColumn("Temperature", new int[] { 12, 13 }); + + DataFrame dataframe = new DataFrame(city, temp); + + // Change the name of the column: + dataframe["City"].SetName("Town"); + var renamedColumn = dataframe["Town"]; + + Assert.Throws(() => dataframe["City"]); + + Assert.NotNull(renamedColumn); + Assert.Equal("Town", renamedColumn.Name); + Assert.True(ReferenceEquals(city, renamedColumn)); + } + + [Fact] + public void RenameColumnWithRenameColumnTests() + { + StringDataFrameColumn city = new StringDataFrameColumn("City", new string[] { "London", "Berlin" }); + PrimitiveDataFrameColumn temp = new PrimitiveDataFrameColumn("Temperature", new int[] { 12, 13 }); + + DataFrame dataframe = new DataFrame(city, temp); + + // Change the name of the column: + dataframe.Columns.RenameColumn("City", "Town"); + var renamedColumn = dataframe["Town"]; + + Assert.Throws(() => dataframe["City"]); + + Assert.NotNull(renamedColumn); + Assert.Equal("Town", renamedColumn.Name); + Assert.True(ReferenceEquals(city, renamedColumn)); + } + [Fact] public void TestBinaryOperations() { From 26c24463a82dd574913aa42646e17d66386cef36 Mon Sep 17 00:00:00 2001 From: Aleksei Smirnov Date: Thu, 6 Jul 2023 22:33:39 +0300 Subject: [PATCH 04/18] Fix DataFrame to allow to store columns with size more than 2 Gb (#6710) * Fix error with allocating more than MaxCapacity of Byte Memory Buffer * Remove Unit test as it consumes too much memory * Fix issue with increasing buffer capacity over limit when double it size --- .../DataFrameBuffer.cs | 5 ++++- .../PrimitiveColumnContainer.cs | 5 +++-- .../ReadOnlyDataFrameBuffer.cs | 5 ++++- .../BufferTests.cs | 22 +++++++++++++++++++ 4 files changed, 33 insertions(+), 4 deletions(-) diff --git a/src/Microsoft.Data.Analysis/DataFrameBuffer.cs b/src/Microsoft.Data.Analysis/DataFrameBuffer.cs index 66abed3ba2..e4ee20f9b6 100644 --- a/src/Microsoft.Data.Analysis/DataFrameBuffer.cs +++ b/src/Microsoft.Data.Analysis/DataFrameBuffer.cs @@ -66,7 +66,10 @@ public void EnsureCapacity(int numberOfValues) if (newLength > Capacity) { - var newCapacity = Math.Max(newLength * Size, ReadOnlyBuffer.Length * 2); + //Double buffer size, but not higher than MaxByteCapacity + var doubledSize = (int)Math.Min((long)ReadOnlyBuffer.Length * 2, MaxCapacityInBytes); + var newCapacity = Math.Max(newLength * Size, doubledSize); + var memory = new Memory(new byte[newCapacity]); _memory.CopyTo(memory); _memory = memory; diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs index 022a6cdfe4..e482d834ec 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs @@ -181,7 +181,9 @@ public void AppendMany(T? value, long count) } DataFrameBuffer mutableLastBuffer = Buffers.GetOrCreateMutable(Buffers.Count - 1); - int allocatable = (int)Math.Min(remaining, ReadOnlyDataFrameBuffer.MaxCapacity); + + //Calculate how many values we can additionaly allocate and not exceed the MaxCapacity + int allocatable = (int)Math.Min(remaining, ReadOnlyDataFrameBuffer.MaxCapacity - mutableLastBuffer.Length); mutableLastBuffer.EnsureCapacity(allocatable); DataFrameBuffer lastNullBitMapBuffer = NullBitMapBuffers.GetOrCreateMutable(NullBitMapBuffers.Count - 1); @@ -205,7 +207,6 @@ public void AppendMany(T? value, long count) _modifyNullCountWhileIndexing = true; } - remaining -= allocatable; } } diff --git a/src/Microsoft.Data.Analysis/ReadOnlyDataFrameBuffer.cs b/src/Microsoft.Data.Analysis/ReadOnlyDataFrameBuffer.cs index b3a8a7bccf..a6a41089e7 100644 --- a/src/Microsoft.Data.Analysis/ReadOnlyDataFrameBuffer.cs +++ b/src/Microsoft.Data.Analysis/ReadOnlyDataFrameBuffer.cs @@ -36,8 +36,11 @@ public ReadOnlyMemory RawReadOnlyMemory protected int Capacity => ReadOnlyBuffer.Length / Size; + //The maximum size in any single dimension for byte array is 0x7FFFFFc7 - 2147483591 + //See https://learn.microsoft.com/en-us/dotnet/framework/configure-apps/file-schema/runtime/gcallowverylargeobjects-element + public const int MaxCapacityInBytes = 2147483591; - public static int MaxCapacity => Int32.MaxValue / Size; + public static int MaxCapacity => MaxCapacityInBytes / Size; public ReadOnlySpan ReadOnlySpan { diff --git a/test/Microsoft.Data.Analysis.Tests/BufferTests.cs b/test/Microsoft.Data.Analysis.Tests/BufferTests.cs index 5f482955f6..830085e626 100644 --- a/test/Microsoft.Data.Analysis.Tests/BufferTests.cs +++ b/test/Microsoft.Data.Analysis.Tests/BufferTests.cs @@ -188,6 +188,28 @@ public void TestArrowStringColumnClone() Assert.Null(clone[i]); } + /* Don't run tests during build as they fail, because build if build machine doesn't have enought memory + [Fact] + public void TestAppend_SizeMoreThanMaxBufferCapacity() + { + //Check appending value, than can increase buffer size over MaxCapacity (default strategy is to double buffer capacity) + PrimitiveDataFrameColumn intColumn = new PrimitiveDataFrameColumn("Byte1", int.MaxValue / 2 - 1); + intColumn.Append(10); + } + + [Fact] + public void TestAppendMany_SizeMoreThanMaxBufferCapacity() + { + const int MaxCapacityInBytes = 2147483591; + + //Check appending values with extending column size over MaxCapacity of ReadOnlyDataFrameBuffer + PrimitiveDataFrameColumn intColumn = new PrimitiveDataFrameColumn("Byte1", MaxCapacityInBytes - 5); + intColumn.AppendMany(5, 10); + + Assert.Equal(MaxCapacityInBytes + 5, intColumn.Length); + } + */ + //#if !NETFRAMEWORK // https://github.com/dotnet/corefxlab/issues/2796 // [Fact] // public void TestPrimitiveColumnGetReadOnlyBuffers() From 36f87d111e3625ce8df682c65e7072325cdd7407 Mon Sep 17 00:00:00 2001 From: Xiaoyun Zhang Date: Thu, 6 Jul 2023 13:16:01 -0700 Subject: [PATCH 05/18] avoid empty dataset (#6756) --- .../AutoMLExperiment/IDatasetManager.cs | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/Microsoft.ML.AutoML/AutoMLExperiment/IDatasetManager.cs b/src/Microsoft.ML.AutoML/AutoMLExperiment/IDatasetManager.cs index fd18fd83fd..e2f373a530 100644 --- a/src/Microsoft.ML.AutoML/AutoMLExperiment/IDatasetManager.cs +++ b/src/Microsoft.ML.AutoML/AutoMLExperiment/IDatasetManager.cs @@ -78,7 +78,15 @@ public IDataView LoadTrainDataset(MLContext context, TrialSettings? settings) var subSampleRatio = parameter.ContainsKey(_subSamplingKey) ? parameter[_subSamplingKey].AsType() : 1; if (subSampleRatio < 1.0) { - var subSampledTrainDataset = context.Data.TakeRows(_trainDataset, (long)(subSampleRatio * _rowCount)); + var count = (long)(subSampleRatio * _rowCount); + if (count <= 10) + { + // fix issue https://github.com/dotnet/machinelearning-modelbuilder/issues/2734 + // take at least 10 rows to avoid empty dataset + count = 10; + } + + var subSampledTrainDataset = context.Data.TakeRows(_trainDataset, count); return subSampledTrainDataset; } } From 69eca5689a1219d1ed31a62875a070658f151306 Mon Sep 17 00:00:00 2001 From: Aleksei Smirnov Date: Fri, 7 Jul 2023 00:00:22 +0300 Subject: [PATCH 06/18] Fix dataframe arithmetics for columns having several value buffers (column size is more than 2 Gb) (#6724) * Fix dataframe arithmetics * Fix --- .../PrimitiveDataFrameColumnArithmetic.cs | 456 ++++++++++++------ .../PrimitiveDataFrameColumnArithmetic.tt | 7 +- 2 files changed, 309 insertions(+), 154 deletions(-) diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs index 05a20ef719..0c8a0ec2ff 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs @@ -307,47 +307,51 @@ public void RightShift(PrimitiveColumnContainer column, int value) } public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == otherSpan[i]); + ret[index++] = (span[i] == otherSpan[i]); } } } public void ElementwiseEquals(PrimitiveColumnContainer column, bool scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == scalar); + ret[index++] = (span[i] == scalar); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != otherSpan[i]); + ret[index++] = (span[i] != otherSpan[i]); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer column, bool scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != scalar); + ret[index++] = (span[i] != scalar); } } } @@ -708,139 +712,151 @@ public void RightShift(PrimitiveColumnContainer column, int value) } public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == otherSpan[i]); + ret[index++] = (span[i] == otherSpan[i]); } } } public void ElementwiseEquals(PrimitiveColumnContainer column, byte scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == scalar); + ret[index++] = (span[i] == scalar); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != otherSpan[i]); + ret[index++] = (span[i] != otherSpan[i]); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer column, byte scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != scalar); + ret[index++] = (span[i] != scalar); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= otherSpan[i]); + ret[index++] = (span[i] >= otherSpan[i]); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, byte scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= scalar); + ret[index++] = (span[i] >= scalar); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= otherSpan[i]); + ret[index++] = (span[i] <= otherSpan[i]); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, byte scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= scalar); + ret[index++] = (span[i] <= scalar); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > otherSpan[i]); + ret[index++] = (span[i] > otherSpan[i]); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer column, byte scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > scalar); + ret[index++] = (span[i] > scalar); } } } public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < otherSpan[i]); + ret[index++] = (span[i] < otherSpan[i]); } } } public void ElementwiseLessThan(PrimitiveColumnContainer column, byte scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < scalar); + ret[index++] = (span[i] < scalar); } } } @@ -1169,139 +1185,151 @@ public void RightShift(PrimitiveColumnContainer column, int value) } public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == otherSpan[i]); + ret[index++] = (span[i] == otherSpan[i]); } } } public void ElementwiseEquals(PrimitiveColumnContainer column, char scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == scalar); + ret[index++] = (span[i] == scalar); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != otherSpan[i]); + ret[index++] = (span[i] != otherSpan[i]); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer column, char scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != scalar); + ret[index++] = (span[i] != scalar); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= otherSpan[i]); + ret[index++] = (span[i] >= otherSpan[i]); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, char scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= scalar); + ret[index++] = (span[i] >= scalar); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= otherSpan[i]); + ret[index++] = (span[i] <= otherSpan[i]); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, char scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= scalar); + ret[index++] = (span[i] <= scalar); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > otherSpan[i]); + ret[index++] = (span[i] > otherSpan[i]); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer column, char scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > scalar); + ret[index++] = (span[i] > scalar); } } } public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < otherSpan[i]); + ret[index++] = (span[i] < otherSpan[i]); } } } public void ElementwiseLessThan(PrimitiveColumnContainer column, char scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < scalar); + ret[index++] = (span[i] < scalar); } } } @@ -1539,139 +1567,151 @@ public void RightShift(PrimitiveColumnContainer column, int value) } public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == otherSpan[i]); + ret[index++] = (span[i] == otherSpan[i]); } } } public void ElementwiseEquals(PrimitiveColumnContainer column, decimal scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == scalar); + ret[index++] = (span[i] == scalar); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != otherSpan[i]); + ret[index++] = (span[i] != otherSpan[i]); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer column, decimal scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != scalar); + ret[index++] = (span[i] != scalar); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= otherSpan[i]); + ret[index++] = (span[i] >= otherSpan[i]); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, decimal scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= scalar); + ret[index++] = (span[i] >= scalar); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= otherSpan[i]); + ret[index++] = (span[i] <= otherSpan[i]); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, decimal scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= scalar); + ret[index++] = (span[i] <= scalar); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > otherSpan[i]); + ret[index++] = (span[i] > otherSpan[i]); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer column, decimal scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > scalar); + ret[index++] = (span[i] > scalar); } } } public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < otherSpan[i]); + ret[index++] = (span[i] < otherSpan[i]); } } } public void ElementwiseLessThan(PrimitiveColumnContainer column, decimal scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < scalar); + ret[index++] = (span[i] < scalar); } } } @@ -1909,139 +1949,151 @@ public void RightShift(PrimitiveColumnContainer column, int value) } public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == otherSpan[i]); + ret[index++] = (span[i] == otherSpan[i]); } } } public void ElementwiseEquals(PrimitiveColumnContainer column, double scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == scalar); + ret[index++] = (span[i] == scalar); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != otherSpan[i]); + ret[index++] = (span[i] != otherSpan[i]); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer column, double scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != scalar); + ret[index++] = (span[i] != scalar); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= otherSpan[i]); + ret[index++] = (span[i] >= otherSpan[i]); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, double scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= scalar); + ret[index++] = (span[i] >= scalar); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= otherSpan[i]); + ret[index++] = (span[i] <= otherSpan[i]); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, double scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= scalar); + ret[index++] = (span[i] <= scalar); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > otherSpan[i]); + ret[index++] = (span[i] > otherSpan[i]); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer column, double scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > scalar); + ret[index++] = (span[i] > scalar); } } } public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < otherSpan[i]); + ret[index++] = (span[i] < otherSpan[i]); } } } public void ElementwiseLessThan(PrimitiveColumnContainer column, double scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < scalar); + ret[index++] = (span[i] < scalar); } } } @@ -2279,139 +2331,151 @@ public void RightShift(PrimitiveColumnContainer column, int value) } public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == otherSpan[i]); + ret[index++] = (span[i] == otherSpan[i]); } } } public void ElementwiseEquals(PrimitiveColumnContainer column, float scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == scalar); + ret[index++] = (span[i] == scalar); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != otherSpan[i]); + ret[index++] = (span[i] != otherSpan[i]); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer column, float scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != scalar); + ret[index++] = (span[i] != scalar); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= otherSpan[i]); + ret[index++] = (span[i] >= otherSpan[i]); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, float scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= scalar); + ret[index++] = (span[i] >= scalar); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= otherSpan[i]); + ret[index++] = (span[i] <= otherSpan[i]); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, float scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= scalar); + ret[index++] = (span[i] <= scalar); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > otherSpan[i]); + ret[index++] = (span[i] > otherSpan[i]); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer column, float scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > scalar); + ret[index++] = (span[i] > scalar); } } } public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < otherSpan[i]); + ret[index++] = (span[i] < otherSpan[i]); } } } public void ElementwiseLessThan(PrimitiveColumnContainer column, float scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < scalar); + ret[index++] = (span[i] < scalar); } } } @@ -2740,139 +2804,151 @@ public void RightShift(PrimitiveColumnContainer column, int value) } public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == otherSpan[i]); + ret[index++] = (span[i] == otherSpan[i]); } } } public void ElementwiseEquals(PrimitiveColumnContainer column, int scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == scalar); + ret[index++] = (span[i] == scalar); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != otherSpan[i]); + ret[index++] = (span[i] != otherSpan[i]); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer column, int scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != scalar); + ret[index++] = (span[i] != scalar); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= otherSpan[i]); + ret[index++] = (span[i] >= otherSpan[i]); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, int scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= scalar); + ret[index++] = (span[i] >= scalar); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= otherSpan[i]); + ret[index++] = (span[i] <= otherSpan[i]); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, int scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= scalar); + ret[index++] = (span[i] <= scalar); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > otherSpan[i]); + ret[index++] = (span[i] > otherSpan[i]); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer column, int scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > scalar); + ret[index++] = (span[i] > scalar); } } } public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < otherSpan[i]); + ret[index++] = (span[i] < otherSpan[i]); } } } public void ElementwiseLessThan(PrimitiveColumnContainer column, int scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < scalar); + ret[index++] = (span[i] < scalar); } } } @@ -3201,139 +3277,151 @@ public void RightShift(PrimitiveColumnContainer column, int value) } public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == otherSpan[i]); + ret[index++] = (span[i] == otherSpan[i]); } } } public void ElementwiseEquals(PrimitiveColumnContainer column, long scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == scalar); + ret[index++] = (span[i] == scalar); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != otherSpan[i]); + ret[index++] = (span[i] != otherSpan[i]); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer column, long scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != scalar); + ret[index++] = (span[i] != scalar); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= otherSpan[i]); + ret[index++] = (span[i] >= otherSpan[i]); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, long scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= scalar); + ret[index++] = (span[i] >= scalar); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= otherSpan[i]); + ret[index++] = (span[i] <= otherSpan[i]); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, long scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= scalar); + ret[index++] = (span[i] <= scalar); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > otherSpan[i]); + ret[index++] = (span[i] > otherSpan[i]); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer column, long scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > scalar); + ret[index++] = (span[i] > scalar); } } } public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < otherSpan[i]); + ret[index++] = (span[i] < otherSpan[i]); } } } public void ElementwiseLessThan(PrimitiveColumnContainer column, long scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < scalar); + ret[index++] = (span[i] < scalar); } } } @@ -3662,139 +3750,151 @@ public void RightShift(PrimitiveColumnContainer column, int value) } public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == otherSpan[i]); + ret[index++] = (span[i] == otherSpan[i]); } } } public void ElementwiseEquals(PrimitiveColumnContainer column, sbyte scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == scalar); + ret[index++] = (span[i] == scalar); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != otherSpan[i]); + ret[index++] = (span[i] != otherSpan[i]); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer column, sbyte scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != scalar); + ret[index++] = (span[i] != scalar); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= otherSpan[i]); + ret[index++] = (span[i] >= otherSpan[i]); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, sbyte scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= scalar); + ret[index++] = (span[i] >= scalar); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= otherSpan[i]); + ret[index++] = (span[i] <= otherSpan[i]); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, sbyte scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= scalar); + ret[index++] = (span[i] <= scalar); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > otherSpan[i]); + ret[index++] = (span[i] > otherSpan[i]); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer column, sbyte scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > scalar); + ret[index++] = (span[i] > scalar); } } } public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < otherSpan[i]); + ret[index++] = (span[i] < otherSpan[i]); } } } public void ElementwiseLessThan(PrimitiveColumnContainer column, sbyte scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < scalar); + ret[index++] = (span[i] < scalar); } } } @@ -4123,139 +4223,151 @@ public void RightShift(PrimitiveColumnContainer column, int value) } public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == otherSpan[i]); + ret[index++] = (span[i] == otherSpan[i]); } } } public void ElementwiseEquals(PrimitiveColumnContainer column, short scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == scalar); + ret[index++] = (span[i] == scalar); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != otherSpan[i]); + ret[index++] = (span[i] != otherSpan[i]); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer column, short scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != scalar); + ret[index++] = (span[i] != scalar); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= otherSpan[i]); + ret[index++] = (span[i] >= otherSpan[i]); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, short scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= scalar); + ret[index++] = (span[i] >= scalar); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= otherSpan[i]); + ret[index++] = (span[i] <= otherSpan[i]); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, short scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= scalar); + ret[index++] = (span[i] <= scalar); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > otherSpan[i]); + ret[index++] = (span[i] > otherSpan[i]); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer column, short scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > scalar); + ret[index++] = (span[i] > scalar); } } } public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < otherSpan[i]); + ret[index++] = (span[i] < otherSpan[i]); } } } public void ElementwiseLessThan(PrimitiveColumnContainer column, short scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < scalar); + ret[index++] = (span[i] < scalar); } } } @@ -4584,139 +4696,151 @@ public void RightShift(PrimitiveColumnContainer column, int value) } public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == otherSpan[i]); + ret[index++] = (span[i] == otherSpan[i]); } } } public void ElementwiseEquals(PrimitiveColumnContainer column, uint scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == scalar); + ret[index++] = (span[i] == scalar); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != otherSpan[i]); + ret[index++] = (span[i] != otherSpan[i]); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer column, uint scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != scalar); + ret[index++] = (span[i] != scalar); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= otherSpan[i]); + ret[index++] = (span[i] >= otherSpan[i]); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, uint scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= scalar); + ret[index++] = (span[i] >= scalar); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= otherSpan[i]); + ret[index++] = (span[i] <= otherSpan[i]); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, uint scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= scalar); + ret[index++] = (span[i] <= scalar); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > otherSpan[i]); + ret[index++] = (span[i] > otherSpan[i]); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer column, uint scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > scalar); + ret[index++] = (span[i] > scalar); } } } public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < otherSpan[i]); + ret[index++] = (span[i] < otherSpan[i]); } } } public void ElementwiseLessThan(PrimitiveColumnContainer column, uint scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < scalar); + ret[index++] = (span[i] < scalar); } } } @@ -5045,139 +5169,151 @@ public void RightShift(PrimitiveColumnContainer column, int value) } public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == otherSpan[i]); + ret[index++] = (span[i] == otherSpan[i]); } } } public void ElementwiseEquals(PrimitiveColumnContainer column, ulong scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == scalar); + ret[index++] = (span[i] == scalar); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != otherSpan[i]); + ret[index++] = (span[i] != otherSpan[i]); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer column, ulong scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != scalar); + ret[index++] = (span[i] != scalar); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= otherSpan[i]); + ret[index++] = (span[i] >= otherSpan[i]); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, ulong scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= scalar); + ret[index++] = (span[i] >= scalar); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= otherSpan[i]); + ret[index++] = (span[i] <= otherSpan[i]); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ulong scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= scalar); + ret[index++] = (span[i] <= scalar); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > otherSpan[i]); + ret[index++] = (span[i] > otherSpan[i]); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer column, ulong scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > scalar); + ret[index++] = (span[i] > scalar); } } } public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < otherSpan[i]); + ret[index++] = (span[i] < otherSpan[i]); } } } public void ElementwiseLessThan(PrimitiveColumnContainer column, ulong scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < scalar); + ret[index++] = (span[i] < scalar); } } } @@ -5506,139 +5642,151 @@ public void RightShift(PrimitiveColumnContainer column, int value) } public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == otherSpan[i]); + ret[index++] = (span[i] == otherSpan[i]); } } } public void ElementwiseEquals(PrimitiveColumnContainer column, ushort scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == scalar); + ret[index++] = (span[i] == scalar); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != otherSpan[i]); + ret[index++] = (span[i] != otherSpan[i]); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer column, ushort scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != scalar); + ret[index++] = (span[i] != scalar); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= otherSpan[i]); + ret[index++] = (span[i] >= otherSpan[i]); } } } public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, ushort scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] >= scalar); + ret[index++] = (span[i] >= scalar); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= otherSpan[i]); + ret[index++] = (span[i] <= otherSpan[i]); } } } public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ushort scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] <= scalar); + ret[index++] = (span[i] <= scalar); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > otherSpan[i]); + ret[index++] = (span[i] > otherSpan[i]); } } } public void ElementwiseGreaterThan(PrimitiveColumnContainer column, ushort scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] > scalar); + ret[index++] = (span[i] > scalar); } } } public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < otherSpan[i]); + ret[index++] = (span[i] < otherSpan[i]); } } } public void ElementwiseLessThan(PrimitiveColumnContainer column, ushort scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] < scalar); + ret[index++] = (span[i] < scalar); } } } @@ -5751,47 +5899,51 @@ public void RightShift(PrimitiveColumnContainer column, int value) } public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == otherSpan[i]); + ret[index++] = (span[i] == otherSpan[i]); } } } public void ElementwiseEquals(PrimitiveColumnContainer column, DateTime scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] == scalar); + ret[index++] = (span[i] == scalar); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { var span = left.Buffers[b].ReadOnlySpan; var otherSpan = right.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != otherSpan[i]); + ret[index++] = (span[i] != otherSpan[i]); } } } public void ElementwiseNotEquals(PrimitiveColumnContainer column, DateTime scalar, PrimitiveColumnContainer ret) { + long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { var span = column.Buffers[b].ReadOnlySpan; for (int i = 0; i < span.Length; i++) { - ret[i] = (span[i] != scalar); + ret[index++] = (span[i] != scalar); } } } diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt index 4262d84c45..a1543efd2d 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt @@ -58,6 +58,9 @@ namespace Microsoft.Data.Analysis <# if ((method.IsNumeric && !type.SupportsNumeric) || (method.IsBitwise && !type.SupportsBitwise) || (type.UnsupportedMethods.Contains(method.MethodName))) { #> throw new NotSupportedException(); <# } else if (method.Operator != null) { #> +<# if (method.MethodType == MethodType.Comparison || method.MethodType == MethodType.ComparisonScalar) { #> + long index = 0; +<# } #> for (int b = 0; b < <#= method.Op1Name #>.Buffers.Count; b++) { <# if (method.MethodType == MethodType.Comparison) { #> @@ -79,9 +82,9 @@ namespace Microsoft.Data.Analysis <# } else if (method.MethodType == MethodType.Binary) { #> span[i] = (<#=type.TypeName#>)(span[i] <#= method.Operator #> otherSpan[i]); <# } else if (method.MethodType == MethodType.Comparison) { #> - ret[i] = (span[i] <#= method.Operator #> otherSpan[i]); + ret[index++] = (span[i] <#= method.Operator #> otherSpan[i]); <# } else if (method.MethodType == MethodType.ComparisonScalar) { #> - ret[i] = (span[i] <#= method.Operator #> <#= method.Op2Name #>); + ret[index++] = (span[i] <#= method.Operator #> <#= method.Op2Name #>); <# } else {#> throw new NotImplementedException(); <# } #> From d9e1ee1e271bf0112d6ea18c3fffa195c47eae2e Mon Sep 17 00:00:00 2001 From: Aleksei Smirnov Date: Fri, 7 Jul 2023 12:39:47 +0300 Subject: [PATCH 07/18] Run tests that requires more than 2 Gb of Memory only on 64-bit env (#6758) --- test/Microsoft.Data.Analysis.Tests/BufferTests.cs | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/test/Microsoft.Data.Analysis.Tests/BufferTests.cs b/test/Microsoft.Data.Analysis.Tests/BufferTests.cs index 830085e626..bc8f66d822 100644 --- a/test/Microsoft.Data.Analysis.Tests/BufferTests.cs +++ b/test/Microsoft.Data.Analysis.Tests/BufferTests.cs @@ -7,6 +7,7 @@ using System.Linq; using System.Text; using Apache.Arrow; +using Microsoft.ML.TestFramework.Attributes; using Xunit; namespace Microsoft.Data.Analysis.Tests @@ -188,8 +189,7 @@ public void TestArrowStringColumnClone() Assert.Null(clone[i]); } - /* Don't run tests during build as they fail, because build if build machine doesn't have enought memory - [Fact] + [X64Fact("32-bit dosn't allow to allocate more than 2 Gb")] public void TestAppend_SizeMoreThanMaxBufferCapacity() { //Check appending value, than can increase buffer size over MaxCapacity (default strategy is to double buffer capacity) @@ -197,7 +197,7 @@ public void TestAppend_SizeMoreThanMaxBufferCapacity() intColumn.Append(10); } - [Fact] + [X64Fact("32-bit dosn't allow to allocate more than 2 Gb")] public void TestAppendMany_SizeMoreThanMaxBufferCapacity() { const int MaxCapacityInBytes = 2147483591; @@ -208,7 +208,6 @@ public void TestAppendMany_SizeMoreThanMaxBufferCapacity() Assert.Equal(MaxCapacityInBytes + 5, intColumn.Length); } - */ //#if !NETFRAMEWORK // https://github.com/dotnet/corefxlab/issues/2796 // [Fact] From caee3c2e2d7ebe5921e206f236ec5e8790a2fc81 Mon Sep 17 00:00:00 2001 From: Aleksei Smirnov Date: Fri, 7 Jul 2023 12:41:49 +0300 Subject: [PATCH 08/18] Reduce coupling of Data.Analysis.Tests project (#6759) --- test/Microsoft.Data.Analysis.Tests/DataFrame.IOTests.cs | 2 +- .../Microsoft.Data.Analysis.Tests.csproj | 2 -- .../Attributes/X64FactAttribute.cs | 1 - .../Attributes/X86X64FactAttribute.cs | 1 - 4 files changed, 1 insertion(+), 5 deletions(-) rename test/{Microsoft.ML.TestFramework => Microsoft.ML.TestFrameworkCommon}/Attributes/X64FactAttribute.cs (93%) rename test/{Microsoft.ML.TestFramework => Microsoft.ML.TestFrameworkCommon}/Attributes/X86X64FactAttribute.cs (94%) diff --git a/test/Microsoft.Data.Analysis.Tests/DataFrame.IOTests.cs b/test/Microsoft.Data.Analysis.Tests/DataFrame.IOTests.cs index 09e95bcae1..05565673b0 100644 --- a/test/Microsoft.Data.Analysis.Tests/DataFrame.IOTests.cs +++ b/test/Microsoft.Data.Analysis.Tests/DataFrame.IOTests.cs @@ -1049,7 +1049,7 @@ public void TestSaveToDataTable() Assert.Equal(vals, resVals); } - [X86X64FactAttribute("The SQLite un-managed code, SQLite.interop, only supports x86/x64 architectures.")] + [X86X64Fact("The SQLite un-managed code, SQLite.interop, only supports x86/x64 architectures.")] public async void TestSQLite() { var (columns, vals) = GetTestData(); diff --git a/test/Microsoft.Data.Analysis.Tests/Microsoft.Data.Analysis.Tests.csproj b/test/Microsoft.Data.Analysis.Tests/Microsoft.Data.Analysis.Tests.csproj index dafae0d942..ce26b374d1 100644 --- a/test/Microsoft.Data.Analysis.Tests/Microsoft.Data.Analysis.Tests.csproj +++ b/test/Microsoft.Data.Analysis.Tests/Microsoft.Data.Analysis.Tests.csproj @@ -7,9 +7,7 @@ - - diff --git a/test/Microsoft.ML.TestFramework/Attributes/X64FactAttribute.cs b/test/Microsoft.ML.TestFrameworkCommon/Attributes/X64FactAttribute.cs similarity index 93% rename from test/Microsoft.ML.TestFramework/Attributes/X64FactAttribute.cs rename to test/Microsoft.ML.TestFrameworkCommon/Attributes/X64FactAttribute.cs index fcc015a73b..993b4c29cd 100644 --- a/test/Microsoft.ML.TestFramework/Attributes/X64FactAttribute.cs +++ b/test/Microsoft.ML.TestFrameworkCommon/Attributes/X64FactAttribute.cs @@ -3,7 +3,6 @@ // See the LICENSE file in the project root for more information. using System; -using Microsoft.ML.TestFrameworkCommon.Attributes; namespace Microsoft.ML.TestFramework.Attributes { diff --git a/test/Microsoft.ML.TestFramework/Attributes/X86X64FactAttribute.cs b/test/Microsoft.ML.TestFrameworkCommon/Attributes/X86X64FactAttribute.cs similarity index 94% rename from test/Microsoft.ML.TestFramework/Attributes/X86X64FactAttribute.cs rename to test/Microsoft.ML.TestFrameworkCommon/Attributes/X86X64FactAttribute.cs index c4f6c2553e..27c8095a1f 100644 --- a/test/Microsoft.ML.TestFramework/Attributes/X86X64FactAttribute.cs +++ b/test/Microsoft.ML.TestFrameworkCommon/Attributes/X86X64FactAttribute.cs @@ -4,7 +4,6 @@ using System; using System.Runtime.InteropServices; -using Microsoft.ML.TestFrameworkCommon.Attributes; namespace Microsoft.ML.TestFramework.Attributes { From 578d7bcb6762f055b0519905954298d68727473e Mon Sep 17 00:00:00 2001 From: Aleksei Smirnov Date: Fri, 7 Jul 2023 18:58:42 +0300 Subject: [PATCH 09/18] Provide ability to filter dataframe column by null via ElementWise Methods (#6723) * Provide ability to filter by null value * Add comments * Fix code review findings --- .../DataFrameColumn.BinaryOperations.cs | 15 ++++ .../DataFrameColumn.BinaryOperations.tt | 9 +++ ...imitiveDataFrameColumn.BinaryOperations.cs | 75 +++++++++++++++++++ ...imitiveDataFrameColumn.BinaryOperations.tt | 13 +++- .../PrimitiveDataFrameColumn.cs | 24 ++++++ .../StringDataFrameColumn.BinaryOperations.cs | 26 +++++++ .../DataFrameTests.cs | 68 +++++++++++++++++ 7 files changed, 229 insertions(+), 1 deletion(-) diff --git a/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.cs b/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.cs index 8ecd052486..1c340575db 100644 --- a/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.cs +++ b/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.cs @@ -316,5 +316,20 @@ public virtual PrimitiveDataFrameColumn ElementwiseLessThan(T value) throw new NotImplementedException(); } + /// + /// Performs an element-wise equal to Null on each value in the column + /// + public virtual PrimitiveDataFrameColumn ElementwiseIsNull() + { + throw new NotImplementedException(); + } + + /// + /// Performs an element-wise not equal to Null on each value in the column + /// + public virtual PrimitiveDataFrameColumn ElementwiseIsNotNull() + { + throw new NotImplementedException(); + } } } diff --git a/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt b/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt index d2e289195c..a417bbf876 100644 --- a/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt +++ b/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt @@ -78,5 +78,14 @@ namespace Microsoft.Data.Analysis <# } #> <# } #> + public virtual PrimitiveDataFrameColumn ElementwiseIsNull() + { + throw new NotImplementedException(); + } + + public virtual PrimitiveDataFrameColumn ElementwiseIsNotNull() + { + throw new NotImplementedException(); + } } } diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs index 2e51f72e63..74506e0904 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs @@ -47,10 +47,12 @@ public override DataFrameColumn Add(DataFrameColumn column, bool inPlace = false return AddImplementation(ushortColumn, inPlace); case PrimitiveDataFrameColumn DateTimeColumn: return AddImplementation(DateTimeColumn, inPlace); + default: throw new NotSupportedException(); } } + /// public override DataFrameColumn Add(U value, bool inPlace = false) { @@ -61,6 +63,7 @@ public override DataFrameColumn Add(U value, bool inPlace = false) } return AddImplementation(value, inPlace); } + /// public override DataFrameColumn Subtract(DataFrameColumn column, bool inPlace = false) { @@ -94,10 +97,12 @@ public override DataFrameColumn Subtract(DataFrameColumn column, bool inPlace = return SubtractImplementation(ushortColumn, inPlace); case PrimitiveDataFrameColumn DateTimeColumn: return SubtractImplementation(DateTimeColumn, inPlace); + default: throw new NotSupportedException(); } } + /// public override DataFrameColumn Subtract(U value, bool inPlace = false) { @@ -108,6 +113,7 @@ public override DataFrameColumn Subtract(U value, bool inPlace = false) } return SubtractImplementation(value, inPlace); } + /// public override DataFrameColumn Multiply(DataFrameColumn column, bool inPlace = false) { @@ -141,10 +147,12 @@ public override DataFrameColumn Multiply(DataFrameColumn column, bool inPlace = return MultiplyImplementation(ushortColumn, inPlace); case PrimitiveDataFrameColumn DateTimeColumn: return MultiplyImplementation(DateTimeColumn, inPlace); + default: throw new NotSupportedException(); } } + /// public override DataFrameColumn Multiply(U value, bool inPlace = false) { @@ -155,6 +163,7 @@ public override DataFrameColumn Multiply(U value, bool inPlace = false) } return MultiplyImplementation(value, inPlace); } + /// public override DataFrameColumn Divide(DataFrameColumn column, bool inPlace = false) { @@ -188,10 +197,12 @@ public override DataFrameColumn Divide(DataFrameColumn column, bool inPlace = fa return DivideImplementation(ushortColumn, inPlace); case PrimitiveDataFrameColumn DateTimeColumn: return DivideImplementation(DateTimeColumn, inPlace); + default: throw new NotSupportedException(); } } + /// public override DataFrameColumn Divide(U value, bool inPlace = false) { @@ -202,6 +213,7 @@ public override DataFrameColumn Divide(U value, bool inPlace = false) } return DivideImplementation(value, inPlace); } + /// public override DataFrameColumn Modulo(DataFrameColumn column, bool inPlace = false) { @@ -235,10 +247,12 @@ public override DataFrameColumn Modulo(DataFrameColumn column, bool inPlace = fa return ModuloImplementation(ushortColumn, inPlace); case PrimitiveDataFrameColumn DateTimeColumn: return ModuloImplementation(DateTimeColumn, inPlace); + default: throw new NotSupportedException(); } } + /// public override DataFrameColumn Modulo(U value, bool inPlace = false) { @@ -249,6 +263,7 @@ public override DataFrameColumn Modulo(U value, bool inPlace = false) } return ModuloImplementation(value, inPlace); } + /// public override DataFrameColumn And(DataFrameColumn column, bool inPlace = false) { @@ -282,15 +297,18 @@ public override DataFrameColumn And(DataFrameColumn column, bool inPlace = false return AndImplementation(ushortColumn, inPlace); case PrimitiveDataFrameColumn DateTimeColumn: return AndImplementation(DateTimeColumn, inPlace); + default: throw new NotSupportedException(); } } + /// public override PrimitiveDataFrameColumn And(bool value, bool inPlace = false) { return AndImplementation(value, inPlace); } + /// public override DataFrameColumn Or(DataFrameColumn column, bool inPlace = false) { @@ -324,15 +342,18 @@ public override DataFrameColumn Or(DataFrameColumn column, bool inPlace = false) return OrImplementation(ushortColumn, inPlace); case PrimitiveDataFrameColumn DateTimeColumn: return OrImplementation(DateTimeColumn, inPlace); + default: throw new NotSupportedException(); } } + /// public override PrimitiveDataFrameColumn Or(bool value, bool inPlace = false) { return OrImplementation(value, inPlace); } + /// public override DataFrameColumn Xor(DataFrameColumn column, bool inPlace = false) { @@ -366,15 +387,18 @@ public override DataFrameColumn Xor(DataFrameColumn column, bool inPlace = false return XorImplementation(ushortColumn, inPlace); case PrimitiveDataFrameColumn DateTimeColumn: return XorImplementation(DateTimeColumn, inPlace); + default: throw new NotSupportedException(); } } + /// public override PrimitiveDataFrameColumn Xor(bool value, bool inPlace = false) { return XorImplementation(value, inPlace); } + /// public override DataFrameColumn LeftShift(int value, bool inPlace = false) { @@ -418,10 +442,14 @@ public override PrimitiveDataFrameColumn ElementwiseEquals(DataFrameColumn return ElementwiseEqualsImplementation(ushortColumn); case PrimitiveDataFrameColumn DateTimeColumn: return ElementwiseEqualsImplementation(DateTimeColumn); + case null: + return ElementwiseIsNull(); + default: throw new NotSupportedException(); } } + /// public override PrimitiveDataFrameColumn ElementwiseEquals(U value) { @@ -432,6 +460,7 @@ public override PrimitiveDataFrameColumn ElementwiseEquals(U value) } return ElementwiseEqualsImplementation(value); } + /// public override PrimitiveDataFrameColumn ElementwiseNotEquals(DataFrameColumn column) { @@ -465,10 +494,14 @@ public override PrimitiveDataFrameColumn ElementwiseNotEquals(DataFrameCol return ElementwiseNotEqualsImplementation(ushortColumn); case PrimitiveDataFrameColumn DateTimeColumn: return ElementwiseNotEqualsImplementation(DateTimeColumn); + case null: + return ElementwiseIsNotNull(); + default: throw new NotSupportedException(); } } + /// public override PrimitiveDataFrameColumn ElementwiseNotEquals(U value) { @@ -479,6 +512,7 @@ public override PrimitiveDataFrameColumn ElementwiseNotEquals(U value) } return ElementwiseNotEqualsImplementation(value); } + /// public override PrimitiveDataFrameColumn ElementwiseGreaterThanOrEqual(DataFrameColumn column) { @@ -512,10 +546,12 @@ public override PrimitiveDataFrameColumn ElementwiseGreaterThanOrEqual(Dat return ElementwiseGreaterThanOrEqualImplementation(ushortColumn); case PrimitiveDataFrameColumn DateTimeColumn: return ElementwiseGreaterThanOrEqualImplementation(DateTimeColumn); + default: throw new NotSupportedException(); } } + /// public override PrimitiveDataFrameColumn ElementwiseGreaterThanOrEqual(U value) { @@ -526,6 +562,7 @@ public override PrimitiveDataFrameColumn ElementwiseGreaterThanOrEqual( } return ElementwiseGreaterThanOrEqualImplementation(value); } + /// public override PrimitiveDataFrameColumn ElementwiseLessThanOrEqual(DataFrameColumn column) { @@ -559,10 +596,12 @@ public override PrimitiveDataFrameColumn ElementwiseLessThanOrEqual(DataFr return ElementwiseLessThanOrEqualImplementation(ushortColumn); case PrimitiveDataFrameColumn DateTimeColumn: return ElementwiseLessThanOrEqualImplementation(DateTimeColumn); + default: throw new NotSupportedException(); } } + /// public override PrimitiveDataFrameColumn ElementwiseLessThanOrEqual(U value) { @@ -573,6 +612,7 @@ public override PrimitiveDataFrameColumn ElementwiseLessThanOrEqual(U v } return ElementwiseLessThanOrEqualImplementation(value); } + /// public override PrimitiveDataFrameColumn ElementwiseGreaterThan(DataFrameColumn column) { @@ -606,10 +646,12 @@ public override PrimitiveDataFrameColumn ElementwiseGreaterThan(DataFrameC return ElementwiseGreaterThanImplementation(ushortColumn); case PrimitiveDataFrameColumn DateTimeColumn: return ElementwiseGreaterThanImplementation(DateTimeColumn); + default: throw new NotSupportedException(); } } + /// public override PrimitiveDataFrameColumn ElementwiseGreaterThan(U value) { @@ -620,6 +662,7 @@ public override PrimitiveDataFrameColumn ElementwiseGreaterThan(U value } return ElementwiseGreaterThanImplementation(value); } + /// public override PrimitiveDataFrameColumn ElementwiseLessThan(DataFrameColumn column) { @@ -653,10 +696,12 @@ public override PrimitiveDataFrameColumn ElementwiseLessThan(DataFrameColu return ElementwiseLessThanImplementation(ushortColumn); case PrimitiveDataFrameColumn DateTimeColumn: return ElementwiseLessThanImplementation(DateTimeColumn); + default: throw new NotSupportedException(); } } + /// public override PrimitiveDataFrameColumn ElementwiseLessThan(U value) { @@ -668,6 +713,7 @@ public override PrimitiveDataFrameColumn ElementwiseLessThan(U value) return ElementwiseLessThanImplementation(value); } + internal DataFrameColumn AddImplementation(PrimitiveDataFrameColumn column, bool inPlace) where U : unmanaged { @@ -750,6 +796,7 @@ internal DataFrameColumn AddImplementation(PrimitiveDataFrameColumn column throw new NotSupportedException(); } } + internal DataFrameColumn AddImplementation(U value, bool inPlace) { switch (typeof(T)) @@ -827,6 +874,7 @@ internal DataFrameColumn AddImplementation(U value, bool inPlace) throw new NotSupportedException(); } } + internal DataFrameColumn SubtractImplementation(PrimitiveDataFrameColumn column, bool inPlace) where U : unmanaged { @@ -909,6 +957,7 @@ internal DataFrameColumn SubtractImplementation(PrimitiveDataFrameColumn c throw new NotSupportedException(); } } + internal DataFrameColumn SubtractImplementation(U value, bool inPlace) { switch (typeof(T)) @@ -986,6 +1035,7 @@ internal DataFrameColumn SubtractImplementation(U value, bool inPlace) throw new NotSupportedException(); } } + internal DataFrameColumn MultiplyImplementation(PrimitiveDataFrameColumn column, bool inPlace) where U : unmanaged { @@ -1068,6 +1118,7 @@ internal DataFrameColumn MultiplyImplementation(PrimitiveDataFrameColumn c throw new NotSupportedException(); } } + internal DataFrameColumn MultiplyImplementation(U value, bool inPlace) { switch (typeof(T)) @@ -1145,6 +1196,7 @@ internal DataFrameColumn MultiplyImplementation(U value, bool inPlace) throw new NotSupportedException(); } } + internal DataFrameColumn DivideImplementation(PrimitiveDataFrameColumn column, bool inPlace) where U : unmanaged { @@ -1227,6 +1279,7 @@ internal DataFrameColumn DivideImplementation(PrimitiveDataFrameColumn col throw new NotSupportedException(); } } + internal DataFrameColumn DivideImplementation(U value, bool inPlace) { switch (typeof(T)) @@ -1304,6 +1357,7 @@ internal DataFrameColumn DivideImplementation(U value, bool inPlace) throw new NotSupportedException(); } } + internal DataFrameColumn ModuloImplementation(PrimitiveDataFrameColumn column, bool inPlace) where U : unmanaged { @@ -1386,6 +1440,7 @@ internal DataFrameColumn ModuloImplementation(PrimitiveDataFrameColumn col throw new NotSupportedException(); } } + internal DataFrameColumn ModuloImplementation(U value, bool inPlace) { switch (typeof(T)) @@ -1463,6 +1518,7 @@ internal DataFrameColumn ModuloImplementation(U value, bool inPlace) throw new NotSupportedException(); } } + internal DataFrameColumn AndImplementation(PrimitiveDataFrameColumn column, bool inPlace) where U : unmanaged { @@ -1498,6 +1554,7 @@ internal DataFrameColumn AndImplementation(PrimitiveDataFrameColumn column throw new NotSupportedException(); } } + internal PrimitiveDataFrameColumn AndImplementation(U value, bool inPlace) { switch (typeof(T)) @@ -1528,6 +1585,7 @@ internal PrimitiveDataFrameColumn AndImplementation(U value, bool inPla throw new NotSupportedException(); } } + internal DataFrameColumn OrImplementation(PrimitiveDataFrameColumn column, bool inPlace) where U : unmanaged { @@ -1563,6 +1621,7 @@ internal DataFrameColumn OrImplementation(PrimitiveDataFrameColumn column, throw new NotSupportedException(); } } + internal PrimitiveDataFrameColumn OrImplementation(U value, bool inPlace) { switch (typeof(T)) @@ -1593,6 +1652,7 @@ internal PrimitiveDataFrameColumn OrImplementation(U value, bool inPlac throw new NotSupportedException(); } } + internal DataFrameColumn XorImplementation(PrimitiveDataFrameColumn column, bool inPlace) where U : unmanaged { @@ -1628,6 +1688,7 @@ internal DataFrameColumn XorImplementation(PrimitiveDataFrameColumn column throw new NotSupportedException(); } } + internal PrimitiveDataFrameColumn XorImplementation(U value, bool inPlace) { switch (typeof(T)) @@ -1658,6 +1719,7 @@ internal PrimitiveDataFrameColumn XorImplementation(U value, bool inPla throw new NotSupportedException(); } } + internal DataFrameColumn LeftShiftImplementation(int value, bool inPlace) { switch (typeof(T)) @@ -1721,6 +1783,7 @@ internal DataFrameColumn LeftShiftImplementation(int value, bool inPlace) throw new NotSupportedException(); } } + internal DataFrameColumn RightShiftImplementation(int value, bool inPlace) { switch (typeof(T)) @@ -1784,6 +1847,7 @@ internal DataFrameColumn RightShiftImplementation(int value, bool inPlace) throw new NotSupportedException(); } } + internal PrimitiveDataFrameColumn ElementwiseEqualsImplementation(PrimitiveDataFrameColumn column) where U : unmanaged { @@ -1873,6 +1937,7 @@ internal PrimitiveDataFrameColumn ElementwiseEqualsImplementation(Primi throw new NotSupportedException(); } } + internal PrimitiveDataFrameColumn ElementwiseEqualsImplementation(U value) { switch (typeof(T)) @@ -1957,6 +2022,7 @@ internal PrimitiveDataFrameColumn ElementwiseEqualsImplementation(U val throw new NotSupportedException(); } } + internal PrimitiveDataFrameColumn ElementwiseNotEqualsImplementation(PrimitiveDataFrameColumn column) where U : unmanaged { @@ -2046,6 +2112,7 @@ internal PrimitiveDataFrameColumn ElementwiseNotEqualsImplementation(Pr throw new NotSupportedException(); } } + internal PrimitiveDataFrameColumn ElementwiseNotEqualsImplementation(U value) { switch (typeof(T)) @@ -2130,6 +2197,7 @@ internal PrimitiveDataFrameColumn ElementwiseNotEqualsImplementation(U throw new NotSupportedException(); } } + internal PrimitiveDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(PrimitiveDataFrameColumn column) where U : unmanaged { @@ -2207,6 +2275,7 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanOrEqualImplementat throw new NotSupportedException(); } } + internal PrimitiveDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(U value) { switch (typeof(T)) @@ -2279,6 +2348,7 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanOrEqualImplementat throw new NotSupportedException(); } } + internal PrimitiveDataFrameColumn ElementwiseLessThanOrEqualImplementation(PrimitiveDataFrameColumn column) where U : unmanaged { @@ -2356,6 +2426,7 @@ internal PrimitiveDataFrameColumn ElementwiseLessThanOrEqualImplementation throw new NotSupportedException(); } } + internal PrimitiveDataFrameColumn ElementwiseLessThanOrEqualImplementation(U value) { switch (typeof(T)) @@ -2428,6 +2499,7 @@ internal PrimitiveDataFrameColumn ElementwiseLessThanOrEqualImplementation throw new NotSupportedException(); } } + internal PrimitiveDataFrameColumn ElementwiseGreaterThanImplementation(PrimitiveDataFrameColumn column) where U : unmanaged { @@ -2505,6 +2577,7 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanImplementation( throw new NotSupportedException(); } } + internal PrimitiveDataFrameColumn ElementwiseGreaterThanImplementation(U value) { switch (typeof(T)) @@ -2577,6 +2650,7 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanImplementation( throw new NotSupportedException(); } } + internal PrimitiveDataFrameColumn ElementwiseLessThanImplementation(PrimitiveDataFrameColumn column) where U : unmanaged { @@ -2654,6 +2728,7 @@ internal PrimitiveDataFrameColumn ElementwiseLessThanImplementation(Pri throw new NotSupportedException(); } } + internal PrimitiveDataFrameColumn ElementwiseLessThanImplementation(U value) { switch (typeof(T)) diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt index 71b7a87339..83a6c80d49 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt @@ -40,10 +40,20 @@ namespace Microsoft.Data.Analysis return <#=method.MethodName#>Implementation(<#=type.TypeName#>Column); <# } #> <# } #> +<# if (method.MethodName == "ElementwiseEquals") {#> + case null: + return ElementwiseIsNull(); +<# } #> +<# if (method.MethodName == "ElementwiseNotEquals") {#> + case null: + return ElementwiseIsNotNull(); +<# } #> + default: throw new NotSupportedException(); } } + <# } #> <# if (method.MethodType == MethodType.BinaryScalar || method.MethodType == MethodType.ComparisonScalar) {#> <# if (method.MethodType == MethodType.BinaryScalar) {#> @@ -79,6 +89,7 @@ namespace Microsoft.Data.Analysis return <#=method.MethodName#>Implementation(value); <# } #> } + <# } #> <# if (method.MethodType == MethodType.BinaryInt ) {#> /// @@ -88,8 +99,8 @@ namespace Microsoft.Data.Analysis } <# } #> <# } #> - <# foreach (MethodConfiguration method in methodConfiguration) { #> + <# if (method.MethodType == MethodType.BinaryScalar || method.MethodType == MethodType.ComparisonScalar) {#> <# if (method.MethodType == MethodType.BinaryScalar) {#> <# if (method.IsBitwise == true) { #> diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs index 4696244e2a..4aca7133ab 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs @@ -864,5 +864,29 @@ public override Dictionary> GetGroupedOccurrences(DataFr { return GetGroupedOccurrences(other, out otherColumnNullIndices); } + + public override PrimitiveDataFrameColumn ElementwiseIsNull() + { + var ret = new BooleanDataFrameColumn(Name, Length); + + for (long i = 0; i < Length; i++) + { + ret[i] = !IsValid(i); + } + + return ret; + } + + public override PrimitiveDataFrameColumn ElementwiseIsNotNull() + { + var ret = new BooleanDataFrameColumn(Name, Length); + + for (long i = 0; i < Length; i++) + { + ret[i] = IsValid(i); + } + + return ret; + } } } diff --git a/src/Microsoft.Data.Analysis/StringDataFrameColumn.BinaryOperations.cs b/src/Microsoft.Data.Analysis/StringDataFrameColumn.BinaryOperations.cs index 0bfbd3b6bc..c6ffe4c4cf 100644 --- a/src/Microsoft.Data.Analysis/StringDataFrameColumn.BinaryOperations.cs +++ b/src/Microsoft.Data.Analysis/StringDataFrameColumn.BinaryOperations.cs @@ -91,6 +91,9 @@ internal static PrimitiveDataFrameColumn ElementwiseEqualsImplementation(D /// public override PrimitiveDataFrameColumn ElementwiseEquals(DataFrameColumn column) { + if (column == null) + return ElementwiseIsNull(); + return ElementwiseEqualsImplementation(this, column); } @@ -128,6 +131,26 @@ internal static PrimitiveDataFrameColumn ElementwiseNotEqualsImplementatio return ret; } + public override PrimitiveDataFrameColumn ElementwiseIsNotNull() + { + PrimitiveDataFrameColumn ret = new PrimitiveDataFrameColumn(Name, Length); + for (long i = 0; i < Length; i++) + { + ret[i] = this[i] != null; + } + return ret; + } + + public override PrimitiveDataFrameColumn ElementwiseIsNull() + { + PrimitiveDataFrameColumn ret = new PrimitiveDataFrameColumn(Name, Length); + for (long i = 0; i < Length; i++) + { + ret[i] = this[i] == null; + } + return ret; + } + public PrimitiveDataFrameColumn ElementwiseNotEquals(string value) { PrimitiveDataFrameColumn ret = new PrimitiveDataFrameColumn(Name, Length); @@ -141,6 +164,9 @@ public PrimitiveDataFrameColumn ElementwiseNotEquals(string value) /// public override PrimitiveDataFrameColumn ElementwiseNotEquals(DataFrameColumn column) { + if (column == null) + return ElementwiseIsNotNull(); + return ElementwiseNotEqualsImplementation(this, column); } diff --git a/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs b/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs index 859eb508ef..8e7b1ea37f 100644 --- a/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs +++ b/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs @@ -3486,5 +3486,73 @@ public void TestMeanMedian() Assert.Equal(4, df["Decimal"].Median()); } + + [Fact] + public void Test_PrimitiveColumnNotEqualsNull() + { + var col = new DoubleDataFrameColumn("col", new double?[] { 1.23, null, 2, 3 }); + var dfTest = new DataFrame(col); + + var filteredNullDf = dfTest.Filter(dfTest["col"].ElementwiseNotEquals(null)); + + Assert.True(filteredNullDf.Columns.IndexOf("col") >= 0); + Assert.Equal(3, filteredNullDf.Columns["col"].Length); + + Assert.Equal(1.23, filteredNullDf.Columns["col"][0]); + Assert.Equal(2.0, filteredNullDf.Columns["col"][1]); + Assert.Equal(3.0, filteredNullDf.Columns["col"][2]); + } + + [Fact] + public void Test_PrimitiveColumnEqualsNull() + { + var index = new Int32DataFrameColumn("index", new int[] { 1, 2, 3, 4, 5 }); + var col = new DoubleDataFrameColumn("col", new double?[] { 1.23, null, 2, 3, null }); ; + var dfTest = new DataFrame(index, col); + + var filteredNullDf = dfTest.Filter(dfTest["col"].ElementwiseEquals(null)); + + Assert.True(filteredNullDf.Columns.IndexOf("col") >= 0); + Assert.True(filteredNullDf.Columns.IndexOf("index") >= 0); + + Assert.Equal(2, filteredNullDf.Rows.Count); + + Assert.Equal(2, filteredNullDf.Columns["index"][0]); + Assert.Equal(5, filteredNullDf.Columns["index"][1]); + } + + [Fact] + public void Test_StringColumnNotEqualsNull() + { + var col = new StringDataFrameColumn("col", new[] { "One", null, "Two", "Three" }); + var dfTest = new DataFrame(col); + + var filteredNullDf = dfTest.Filter(dfTest["col"].ElementwiseNotEquals(null)); + + Assert.True(filteredNullDf.Columns.IndexOf("col") >= 0); + Assert.Equal(3, filteredNullDf.Columns["col"].Length); + + Assert.Equal("One", filteredNullDf.Columns["col"][0]); + Assert.Equal("Two", filteredNullDf.Columns["col"][1]); + Assert.Equal("Three", filteredNullDf.Columns["col"][2]); + } + + [Fact] + public void Test_StringColumnEqualsNull() + { + var index = new Int32DataFrameColumn("index", new int[] { 1, 2, 3, 4, 5 }); + var col = new StringDataFrameColumn("col", new[] { "One", null, "Three", "Four", null }); ; + var dfTest = new DataFrame(index, col); + + var filteredNullDf = dfTest.Filter(dfTest["col"].ElementwiseEquals(null)); + + Assert.True(filteredNullDf.Columns.IndexOf("col") >= 0); + Assert.True(filteredNullDf.Columns.IndexOf("index") >= 0); + + Assert.Equal(2, filteredNullDf.Rows.Count); + + Assert.Equal(2, filteredNullDf.Columns["index"][0]); + Assert.Equal(5, filteredNullDf.Columns["index"][1]); + } } } From 69cc4bcb7600a62b7bd81c485d5036c8b662c42a Mon Sep 17 00:00:00 2001 From: Aleksei Smirnov Date: Sat, 8 Jul 2023 01:22:02 +0300 Subject: [PATCH 10/18] Fix incorrect DataFrame min max computation with NULL (#6734) * Step 1 * Step 2 * Fixed code review findings --- .../DateTimeComputation.cs | 57 +- .../PrimitiveColumnContainer.cs | 41 +- .../PrimitiveDataFrameColumn.Computations.cs | 16 +- .../PrimitiveDataFrameColumn.Computations.tt | 6 +- .../PrimitiveDataFrameColumn.Sort.cs | 2 +- .../PrimitiveDataFrameColumn.cs | 2 +- .../PrimitiveDataFrameColumnComputations.cs | 992 +++++++++++------- .../PrimitiveDataFrameColumnComputations.tt | 54 +- .../DataFrameTests.cs | 66 ++ 9 files changed, 791 insertions(+), 445 deletions(-) diff --git a/src/Microsoft.Data.Analysis/DateTimeComputation.cs b/src/Microsoft.Data.Analysis/DateTimeComputation.cs index 5335d30f87..ef052b4011 100644 --- a/src/Microsoft.Data.Analysis/DateTimeComputation.cs +++ b/src/Microsoft.Data.Analysis/DateTimeComputation.cs @@ -4,6 +4,8 @@ using System; using System.Collections.Generic; +using System.Diagnostics; +using System.Reflection; using System.Text; namespace Microsoft.Data.Analysis @@ -189,26 +191,35 @@ public void CumulativeSum(PrimitiveColumnContainer column, IEnumerable throw new NotSupportedException(); } - public void Max(PrimitiveColumnContainer column, out DateTime ret) + public void Max(PrimitiveColumnContainer column, out DateTime? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var maxDate = DateTime.MinValue; + bool hasMaxValue = false; + for (int b = 0; b < column.Buffers.Count; b++) { - var buffer = column.Buffers[b]; - var readOnlySpan = buffer.ReadOnlySpan; + var readOnlySpan = column.Buffers[b].ReadOnlySpan; + var bitmapSpan = column.NullBitMapBuffers[b].ReadOnlySpan; for (int i = 0; i < readOnlySpan.Length; i++) { + //Check if bit is not set (value is null) - skip + if (!BitmapHelper.IsValid(bitmapSpan, i)) + continue; + var val = readOnlySpan[i]; - if (val > ret) + if (val > maxDate) { - ret = val; + maxDate = val; + hasMaxValue = true; } } } + + ret = hasMaxValue ? maxDate : null; } - public void Max(PrimitiveColumnContainer column, IEnumerable rows, out DateTime ret) + public void Max(PrimitiveColumnContainer column, IEnumerable rows, out DateTime? ret) { ret = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; @@ -237,26 +248,36 @@ public void Max(PrimitiveColumnContainer column, IEnumerable row } } - public void Min(PrimitiveColumnContainer column, out DateTime ret) + public void Min(PrimitiveColumnContainer column, out DateTime? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var minDate = DateTime.MaxValue; + bool hasMinValue = false; + for (int b = 0; b < column.Buffers.Count; b++) { - var buffer = column.Buffers[b]; - var readOnlySpan = buffer.ReadOnlySpan; + var readOnlySpan = column.Buffers[b].ReadOnlySpan; + var bitmapSpan = column.NullBitMapBuffers[b].ReadOnlySpan; + for (int i = 0; i < readOnlySpan.Length; i++) { + //Check if bit is not set (value is null) - skip + if (!BitmapHelper.IsValid(bitmapSpan, i)) + continue; + var val = readOnlySpan[i]; - if (val < ret) + if (val < minDate) { - ret = val; + minDate = val; + hasMinValue = true; } } } + + ret = hasMinValue ? minDate : null; } - public void Min(PrimitiveColumnContainer column, IEnumerable rows, out DateTime ret) + public void Min(PrimitiveColumnContainer column, IEnumerable rows, out DateTime? ret) { ret = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; @@ -285,22 +306,22 @@ public void Min(PrimitiveColumnContainer column, IEnumerable row } } - public void Product(PrimitiveColumnContainer column, out DateTime ret) + public void Product(PrimitiveColumnContainer column, out DateTime? ret) { throw new NotSupportedException(); } - public void Product(PrimitiveColumnContainer column, IEnumerable rows, out DateTime ret) + public void Product(PrimitiveColumnContainer column, IEnumerable rows, out DateTime? ret) { throw new NotSupportedException(); } - public void Sum(PrimitiveColumnContainer column, out DateTime ret) + public void Sum(PrimitiveColumnContainer column, out DateTime? ret) { throw new NotSupportedException(); } - public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out DateTime ret) + public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out DateTime? ret) { throw new NotSupportedException(); } diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs index e482d834ec..745d1800e9 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs @@ -12,8 +12,24 @@ namespace Microsoft.Data.Analysis { + internal static class BitmapHelper + { + // Faster to use when we already have a span since it avoids indexing + public static bool IsValid(ReadOnlySpan bitMapBufferSpan, int index) + { + int nullBitMapSpanIndex = index / 8; + byte thisBitMap = bitMapBufferSpan[nullBitMapSpanIndex]; + return IsBitSet(thisBitMap, index); + } + + public static bool IsBitSet(byte curBitMap, int index) + { + return ((curBitMap >> (index & 7)) & 1) != 0; + } + } + /// - /// PrimitiveDataFrameColumnContainer is just a store for the column data. APIs that want to change the data must be defined in PrimitiveDataFrameColumn + /// PrimitiveColumnContainer is just a store for the column data. APIs that want to change the data must be defined in PrimitiveDataFrameColumn /// /// internal partial class PrimitiveColumnContainer : IEnumerable @@ -224,7 +240,7 @@ public void ApplyElementwise(Func func) for (int i = 0; i < mutableBuffer.Length; i++) { long curIndex = i + prevLength; - bool isValid = IsValid(mutableNullBitMapBuffer, i); + bool isValid = BitmapHelper.IsValid(mutableNullBitMapBuffer, i); T? value = func(isValid ? mutableBuffer[i] : null, curIndex); mutableBuffer[i] = value.GetValueOrDefault(); SetValidityBit(mutableNullBitMapBuffer, i, value != null); @@ -247,7 +263,7 @@ public void Apply(Func func, PrimitiveColumnContainer(Func func, PrimitiveColumnContainer bitMapBufferSpan, int index) - { - int nullBitMapSpanIndex = index / 8; - byte thisBitMap = bitMapBufferSpan[nullBitMapSpanIndex]; - return IsBitSet(thisBitMap, index); - } - public bool IsValid(long index) => NullCount == 0 || GetValidityBit(index); private byte SetBit(byte curBitMap, int index, bool value) @@ -330,11 +338,6 @@ internal void SetValidityBit(long index, bool value) SetValidityBit(bitMapBuffer.Span, (int)index, value); } - private bool IsBitSet(byte curBitMap, int index) - { - return ((curBitMap >> (index & 7)) & 1) != 0; - } - private bool GetValidityBit(long index) { if ((uint)index >= Length) @@ -351,7 +354,7 @@ private bool GetValidityBit(long index) int bitMapBufferIndex = (int)((uint)index / 8); Debug.Assert(bitMapBuffer.Length > bitMapBufferIndex); byte curBitMap = bitMapBuffer[bitMapBufferIndex]; - return IsBitSet(curBitMap, (int)index); + return BitmapHelper.IsBitSet(curBitMap, (int)index); } public long Length; @@ -513,7 +516,7 @@ public PrimitiveColumnContainer Clone(PrimitiveColumnContainer mapIndic spanIndex = buffer.Length - 1 - i; long mapRowIndex = mapIndicesIntSpan.IsEmpty ? mapIndicesLongSpan[spanIndex] : mapIndicesIntSpan[spanIndex]; - bool mapRowIndexIsValid = mapIndices.IsValid(mapIndicesNullBitMapSpan, spanIndex); + bool mapRowIndexIsValid = BitmapHelper.IsValid(mapIndicesNullBitMapSpan, spanIndex); if (mapRowIndexIsValid && (mapRowIndex < minRange || mapRowIndex >= maxRange)) { int bufferIndex = (int)(mapRowIndex / maxCapacity); @@ -528,7 +531,7 @@ public PrimitiveColumnContainer Clone(PrimitiveColumnContainer mapIndic { mapRowIndex -= minRange; value = thisSpan[(int)mapRowIndex]; - isValid = IsValid(thisNullBitMapSpan, (int)mapRowIndex); + isValid = BitmapHelper.IsValid(thisNullBitMapSpan, (int)mapRowIndex); } retSpan[i] = isValid ? value : default; diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.Computations.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.Computations.cs index 58e6a1e7c5..5501236c03 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.Computations.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.Computations.cs @@ -93,49 +93,49 @@ public override DataFrameColumn CumulativeSum(IEnumerable rowIndices, bool /// public override object Max() { - PrimitiveColumnComputation.Instance.Max(_columnContainer, out T ret); + PrimitiveColumnComputation.Instance.Max(_columnContainer, out T? ret); return ret; } /// public override object Max(IEnumerable rowIndices) { - PrimitiveColumnComputation.Instance.Max(_columnContainer, rowIndices, out T ret); + PrimitiveColumnComputation.Instance.Max(_columnContainer, rowIndices, out T? ret); return ret; } /// public override object Min() { - PrimitiveColumnComputation.Instance.Min(_columnContainer, out T ret); + PrimitiveColumnComputation.Instance.Min(_columnContainer, out T? ret); return ret; } /// public override object Min(IEnumerable rowIndices) { - PrimitiveColumnComputation.Instance.Min(_columnContainer, rowIndices, out T ret); + PrimitiveColumnComputation.Instance.Min(_columnContainer, rowIndices, out T? ret); return ret; } /// public override object Product() { - PrimitiveColumnComputation.Instance.Product(_columnContainer, out T ret); + PrimitiveColumnComputation.Instance.Product(_columnContainer, out T? ret); return ret; } /// public override object Product(IEnumerable rowIndices) { - PrimitiveColumnComputation.Instance.Product(_columnContainer, rowIndices, out T ret); + PrimitiveColumnComputation.Instance.Product(_columnContainer, rowIndices, out T? ret); return ret; } /// public override object Sum() { - PrimitiveColumnComputation.Instance.Sum(_columnContainer, out T ret); + PrimitiveColumnComputation.Instance.Sum(_columnContainer, out T? ret); return ret; } /// public override object Sum(IEnumerable rowIndices) { - PrimitiveColumnComputation.Instance.Sum(_columnContainer, rowIndices, out T ret); + PrimitiveColumnComputation.Instance.Sum(_columnContainer, rowIndices, out T? ret); return ret; } /// diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.Computations.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.Computations.tt index 0d09ea3e37..763762c4b4 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.Computations.tt +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.Computations.tt @@ -51,13 +51,13 @@ namespace Microsoft.Data.Analysis PrimitiveColumnComputation.Instance.<#=compMethod.MethodName#>(ret._columnContainer); return ret; <# } else if (compMethod.MethodType == MethodType.ElementwiseComputation && compMethod.HasReturnValue == true) {#> - PrimitiveColumnComputation.Instance.<#=compMethod.MethodName#>(_columnContainer, out T ret); + PrimitiveColumnComputation.Instance.<#=compMethod.MethodName#>(_columnContainer, out T? ret); return ret; <# } else if (compMethod.MethodType == MethodType.Reduction && compMethod.IsNumeric == true && compMethod.SupportsRowSubsets == true) { #> - PrimitiveColumnComputation.Instance.<#=compMethod.MethodName#>(_columnContainer, rowIndices, out T ret); + PrimitiveColumnComputation.Instance.<#=compMethod.MethodName#>(_columnContainer, rowIndices, out T? ret); return ret; <# } else if (compMethod.MethodType == MethodType.Reduction && compMethod.IsNumeric == true) { #> - PrimitiveColumnComputation.Instance.<#=compMethod.MethodName#>(_columnContainer, out T ret); + PrimitiveColumnComputation.Instance.<#=compMethod.MethodName#>(_columnContainer, out T? ret); return ret; <# } else { #> PrimitiveColumnComputation.Instance.<#=compMethod.MethodName#>(_columnContainer, out bool ret); diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.Sort.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.Sort.cs index d83c601777..a70bc1aecc 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.Sort.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.Sort.cs @@ -45,7 +45,7 @@ private Int64DataFrameColumn GetSortIndices(IComparer comparer, out Int64Data for (int i = 0; i < sortIndices.Length; i++) { int localSortIndex = sortIndices[i]; - if (_columnContainer.IsValid(nullBitMapSpan, localSortIndex)) + if (BitmapHelper.IsValid(nullBitMapSpan, localSortIndex)) { nonNullSortIndices.Add(sortIndices[i]); } diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs index 4aca7133ab..69eeb2d18b 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs @@ -584,7 +584,7 @@ public override Dictionary> GroupColumnValues(out for (int i = 0; i < readOnlySpan.Length; i++) { long currentLength = i + previousLength; - if (_columnContainer.IsValid(nullBitMapSpan, i)) + if (BitmapHelper.IsValid(nullBitMapSpan, i)) { bool containsKey = multimap.TryGetValue(readOnlySpan[i], out ICollection values); if (containsKey) diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.cs index dd1ad7542e..cf01656497 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.cs @@ -25,14 +25,14 @@ internal interface IPrimitiveColumnComputation void CumulativeProduct(PrimitiveColumnContainer column, IEnumerable rows); void CumulativeSum(PrimitiveColumnContainer column); void CumulativeSum(PrimitiveColumnContainer column, IEnumerable rows); - void Max(PrimitiveColumnContainer column, out T ret); - void Max(PrimitiveColumnContainer column, IEnumerable rows, out T ret); - void Min(PrimitiveColumnContainer column, out T ret); - void Min(PrimitiveColumnContainer column, IEnumerable rows, out T ret); - void Product(PrimitiveColumnContainer column, out T ret); - void Product(PrimitiveColumnContainer column, IEnumerable rows, out T ret); - void Sum(PrimitiveColumnContainer column, out T ret); - void Sum(PrimitiveColumnContainer column, IEnumerable rows, out T ret); + void Max(PrimitiveColumnContainer column, out T? ret); + void Max(PrimitiveColumnContainer column, IEnumerable rows, out T? ret); + void Min(PrimitiveColumnContainer column, out T? ret); + void Min(PrimitiveColumnContainer column, IEnumerable rows, out T? ret); + void Product(PrimitiveColumnContainer column, out T? ret); + void Product(PrimitiveColumnContainer column, IEnumerable rows, out T? ret); + void Sum(PrimitiveColumnContainer column, out T? ret); + void Sum(PrimitiveColumnContainer column, IEnumerable rows, out T? ret); void Round(PrimitiveColumnContainer column); } @@ -195,42 +195,42 @@ public void CumulativeSum(PrimitiveColumnContainer column, IEnumerable column, out bool ret) + public void Max(PrimitiveColumnContainer column, out bool? ret) { throw new NotSupportedException(); } - public void Max(PrimitiveColumnContainer column, IEnumerable rows, out bool ret) + public void Max(PrimitiveColumnContainer column, IEnumerable rows, out bool? ret) { throw new NotSupportedException(); } - public void Min(PrimitiveColumnContainer column, out bool ret) + public void Min(PrimitiveColumnContainer column, out bool? ret) { throw new NotSupportedException(); } - public void Min(PrimitiveColumnContainer column, IEnumerable rows, out bool ret) + public void Min(PrimitiveColumnContainer column, IEnumerable rows, out bool? ret) { throw new NotSupportedException(); } - public void Product(PrimitiveColumnContainer column, out bool ret) + public void Product(PrimitiveColumnContainer column, out bool? ret) { throw new NotSupportedException(); } - public void Product(PrimitiveColumnContainer column, IEnumerable rows, out bool ret) + public void Product(PrimitiveColumnContainer column, IEnumerable rows, out bool? ret) { throw new NotSupportedException(); } - public void Sum(PrimitiveColumnContainer column, out bool ret) + public void Sum(PrimitiveColumnContainer column, out bool? ret) { throw new NotSupportedException(); } - public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out bool ret) + public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out bool? ret) { throw new NotSupportedException(); } @@ -281,7 +281,7 @@ public void CumulativeMax(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (byte)(Math.Max(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -345,7 +345,7 @@ public void CumulativeMin(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (byte)(Math.Min(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -409,7 +409,7 @@ public void CumulativeProduct(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (byte)(readOnlySpan[i] * ret); mutableSpan[i] = ret; @@ -473,7 +473,7 @@ public void CumulativeSum(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (byte)(readOnlySpan[i] + ret); mutableSpan[i] = ret; @@ -524,9 +524,10 @@ public void CumulativeSum(PrimitiveColumnContainer column, IEnumerable column, out byte ret) + public void Max(PrimitiveColumnContainer column, out byte? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = byte.MinValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -535,17 +536,20 @@ public void Max(PrimitiveColumnContainer column, out byte ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (byte)(Math.Max(readOnlySpan[i], ret)); + hasValue = true; + value = (byte)(Math.Max(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Max(PrimitiveColumnContainer column, IEnumerable rows, out byte ret) + public void Max(PrimitiveColumnContainer column, IEnumerable rows, out byte? ret) { - ret = byte.MinValue; + var value = byte.MinValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -562,13 +566,16 @@ public void Max(PrimitiveColumnContainer column, IEnumerable rows, o maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (byte)(Math.Max(readOnlySpan[(int)row], ret)); + value = (byte)(Math.Max(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Min(PrimitiveColumnContainer column, out byte ret) + public void Min(PrimitiveColumnContainer column, out byte? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = byte.MaxValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -577,17 +584,20 @@ public void Min(PrimitiveColumnContainer column, out byte ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (byte)(Math.Min(readOnlySpan[i], ret)); + hasValue = true; + value = (byte)(Math.Min(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Min(PrimitiveColumnContainer column, IEnumerable rows, out byte ret) + public void Min(PrimitiveColumnContainer column, IEnumerable rows, out byte? ret) { - ret = byte.MaxValue; + var value = byte.MaxValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -604,11 +614,13 @@ public void Min(PrimitiveColumnContainer column, IEnumerable rows, o maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (byte)(Math.Min(readOnlySpan[(int)row], ret)); + value = (byte)(Math.Min(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Product(PrimitiveColumnContainer column, out byte ret) + public void Product(PrimitiveColumnContainer column, out byte? ret) { ret = (byte)1; for (int b = 0; b < column.Buffers.Count; b++) @@ -619,7 +631,7 @@ public void Product(PrimitiveColumnContainer column, out byte ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (byte)(readOnlySpan[i] * ret); } @@ -627,9 +639,9 @@ public void Product(PrimitiveColumnContainer column, out byte ret) } } - public void Product(PrimitiveColumnContainer column, IEnumerable rows, out byte ret) + public void Product(PrimitiveColumnContainer column, IEnumerable rows, out byte? ret) { - ret = default; + byte value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -646,13 +658,16 @@ public void Product(PrimitiveColumnContainer column, IEnumerable row maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((byte)(readOnlySpan[(int)row] * ret)); + value = checked((byte)(readOnlySpan[(int)row] * value)); } + + ret = value; } - public void Sum(PrimitiveColumnContainer column, out byte ret) + public void Sum(PrimitiveColumnContainer column, out byte? ret) { - ret = (byte)0; + var value = (byte)0; + var hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -661,17 +676,20 @@ public void Sum(PrimitiveColumnContainer column, out byte ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (byte)(readOnlySpan[i] + ret); + hasValue = true; + value = (byte)(readOnlySpan[i] + value); } } } + + ret = hasValue ? value : null; } - public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out byte ret) + public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out byte? ret) { - ret = default; + byte value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -688,8 +706,10 @@ public void Sum(PrimitiveColumnContainer column, IEnumerable rows, o maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((byte)(readOnlySpan[(int)row] + ret)); + value = checked((byte)(readOnlySpan[(int)row] + value)); } + + ret = value; } public void Round(PrimitiveColumnContainer column) @@ -748,7 +768,7 @@ public void CumulativeMax(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (char)(Math.Max(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -812,7 +832,7 @@ public void CumulativeMin(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (char)(Math.Min(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -876,7 +896,7 @@ public void CumulativeProduct(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (char)(readOnlySpan[i] * ret); mutableSpan[i] = ret; @@ -940,7 +960,7 @@ public void CumulativeSum(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (char)(readOnlySpan[i] + ret); mutableSpan[i] = ret; @@ -991,9 +1011,10 @@ public void CumulativeSum(PrimitiveColumnContainer column, IEnumerable column, out char ret) + public void Max(PrimitiveColumnContainer column, out char? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = char.MinValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -1002,17 +1023,20 @@ public void Max(PrimitiveColumnContainer column, out char ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (char)(Math.Max(readOnlySpan[i], ret)); + hasValue = true; + value = (char)(Math.Max(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Max(PrimitiveColumnContainer column, IEnumerable rows, out char ret) + public void Max(PrimitiveColumnContainer column, IEnumerable rows, out char? ret) { - ret = char.MinValue; + var value = char.MinValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -1029,13 +1053,16 @@ public void Max(PrimitiveColumnContainer column, IEnumerable rows, o maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (char)(Math.Max(readOnlySpan[(int)row], ret)); + value = (char)(Math.Max(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Min(PrimitiveColumnContainer column, out char ret) + public void Min(PrimitiveColumnContainer column, out char? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = char.MaxValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -1044,17 +1071,20 @@ public void Min(PrimitiveColumnContainer column, out char ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (char)(Math.Min(readOnlySpan[i], ret)); + hasValue = true; + value = (char)(Math.Min(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Min(PrimitiveColumnContainer column, IEnumerable rows, out char ret) + public void Min(PrimitiveColumnContainer column, IEnumerable rows, out char? ret) { - ret = char.MaxValue; + var value = char.MaxValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -1071,11 +1101,13 @@ public void Min(PrimitiveColumnContainer column, IEnumerable rows, o maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (char)(Math.Min(readOnlySpan[(int)row], ret)); + value = (char)(Math.Min(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Product(PrimitiveColumnContainer column, out char ret) + public void Product(PrimitiveColumnContainer column, out char? ret) { ret = (char)1; for (int b = 0; b < column.Buffers.Count; b++) @@ -1086,7 +1118,7 @@ public void Product(PrimitiveColumnContainer column, out char ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (char)(readOnlySpan[i] * ret); } @@ -1094,9 +1126,9 @@ public void Product(PrimitiveColumnContainer column, out char ret) } } - public void Product(PrimitiveColumnContainer column, IEnumerable rows, out char ret) + public void Product(PrimitiveColumnContainer column, IEnumerable rows, out char? ret) { - ret = default; + char value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -1113,13 +1145,16 @@ public void Product(PrimitiveColumnContainer column, IEnumerable row maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((char)(readOnlySpan[(int)row] * ret)); + value = checked((char)(readOnlySpan[(int)row] * value)); } + + ret = value; } - public void Sum(PrimitiveColumnContainer column, out char ret) + public void Sum(PrimitiveColumnContainer column, out char? ret) { - ret = (char)0; + var value = (char)0; + var hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -1128,17 +1163,20 @@ public void Sum(PrimitiveColumnContainer column, out char ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (char)(readOnlySpan[i] + ret); + hasValue = true; + value = (char)(readOnlySpan[i] + value); } } } + + ret = hasValue ? value : null; } - public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out char ret) + public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out char? ret) { - ret = default; + char value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -1155,8 +1193,10 @@ public void Sum(PrimitiveColumnContainer column, IEnumerable rows, o maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((char)(readOnlySpan[(int)row] + ret)); + value = checked((char)(readOnlySpan[(int)row] + value)); } + + ret = value; } public void Round(PrimitiveColumnContainer column) @@ -1215,7 +1255,7 @@ public void CumulativeMax(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (decimal)(Math.Max(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -1279,7 +1319,7 @@ public void CumulativeMin(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (decimal)(Math.Min(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -1343,7 +1383,7 @@ public void CumulativeProduct(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (decimal)(readOnlySpan[i] * ret); mutableSpan[i] = ret; @@ -1407,7 +1447,7 @@ public void CumulativeSum(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (decimal)(readOnlySpan[i] + ret); mutableSpan[i] = ret; @@ -1458,9 +1498,10 @@ public void CumulativeSum(PrimitiveColumnContainer column, IEnumerable< } } - public void Max(PrimitiveColumnContainer column, out decimal ret) + public void Max(PrimitiveColumnContainer column, out decimal? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = decimal.MinValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -1469,17 +1510,20 @@ public void Max(PrimitiveColumnContainer column, out decimal ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (decimal)(Math.Max(readOnlySpan[i], ret)); + hasValue = true; + value = (decimal)(Math.Max(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Max(PrimitiveColumnContainer column, IEnumerable rows, out decimal ret) + public void Max(PrimitiveColumnContainer column, IEnumerable rows, out decimal? ret) { - ret = decimal.MinValue; + var value = decimal.MinValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -1496,13 +1540,16 @@ public void Max(PrimitiveColumnContainer column, IEnumerable rows maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (decimal)(Math.Max(readOnlySpan[(int)row], ret)); + value = (decimal)(Math.Max(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Min(PrimitiveColumnContainer column, out decimal ret) + public void Min(PrimitiveColumnContainer column, out decimal? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = decimal.MaxValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -1511,17 +1558,20 @@ public void Min(PrimitiveColumnContainer column, out decimal ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (decimal)(Math.Min(readOnlySpan[i], ret)); + hasValue = true; + value = (decimal)(Math.Min(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Min(PrimitiveColumnContainer column, IEnumerable rows, out decimal ret) + public void Min(PrimitiveColumnContainer column, IEnumerable rows, out decimal? ret) { - ret = decimal.MaxValue; + var value = decimal.MaxValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -1538,11 +1588,13 @@ public void Min(PrimitiveColumnContainer column, IEnumerable rows maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (decimal)(Math.Min(readOnlySpan[(int)row], ret)); + value = (decimal)(Math.Min(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Product(PrimitiveColumnContainer column, out decimal ret) + public void Product(PrimitiveColumnContainer column, out decimal? ret) { ret = (decimal)1; for (int b = 0; b < column.Buffers.Count; b++) @@ -1553,7 +1605,7 @@ public void Product(PrimitiveColumnContainer column, out decimal ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (decimal)(readOnlySpan[i] * ret); } @@ -1561,9 +1613,9 @@ public void Product(PrimitiveColumnContainer column, out decimal ret) } } - public void Product(PrimitiveColumnContainer column, IEnumerable rows, out decimal ret) + public void Product(PrimitiveColumnContainer column, IEnumerable rows, out decimal? ret) { - ret = default; + decimal value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -1580,13 +1632,16 @@ public void Product(PrimitiveColumnContainer column, IEnumerable maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((decimal)(readOnlySpan[(int)row] * ret)); + value = checked((decimal)(readOnlySpan[(int)row] * value)); } + + ret = value; } - public void Sum(PrimitiveColumnContainer column, out decimal ret) + public void Sum(PrimitiveColumnContainer column, out decimal? ret) { - ret = (decimal)0; + var value = (decimal)0; + var hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -1595,17 +1650,20 @@ public void Sum(PrimitiveColumnContainer column, out decimal ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (decimal)(readOnlySpan[i] + ret); + hasValue = true; + value = (decimal)(readOnlySpan[i] + value); } } } + + ret = hasValue ? value : null; } - public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out decimal ret) + public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out decimal? ret) { - ret = default; + decimal value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -1622,8 +1680,10 @@ public void Sum(PrimitiveColumnContainer column, IEnumerable rows maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((decimal)(readOnlySpan[(int)row] + ret)); + value = checked((decimal)(readOnlySpan[(int)row] + value)); } + + ret = value; } public void Round(PrimitiveColumnContainer column) @@ -1682,7 +1742,7 @@ public void CumulativeMax(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (double)(Math.Max(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -1746,7 +1806,7 @@ public void CumulativeMin(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (double)(Math.Min(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -1810,7 +1870,7 @@ public void CumulativeProduct(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (double)(readOnlySpan[i] * ret); mutableSpan[i] = ret; @@ -1874,7 +1934,7 @@ public void CumulativeSum(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (double)(readOnlySpan[i] + ret); mutableSpan[i] = ret; @@ -1925,9 +1985,10 @@ public void CumulativeSum(PrimitiveColumnContainer column, IEnumerable column, out double ret) + public void Max(PrimitiveColumnContainer column, out double? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = double.MinValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -1936,17 +1997,20 @@ public void Max(PrimitiveColumnContainer column, out double ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (double)(Math.Max(readOnlySpan[i], ret)); + hasValue = true; + value = (double)(Math.Max(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Max(PrimitiveColumnContainer column, IEnumerable rows, out double ret) + public void Max(PrimitiveColumnContainer column, IEnumerable rows, out double? ret) { - ret = double.MinValue; + var value = double.MinValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -1963,13 +2027,16 @@ public void Max(PrimitiveColumnContainer column, IEnumerable rows, maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (double)(Math.Max(readOnlySpan[(int)row], ret)); + value = (double)(Math.Max(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Min(PrimitiveColumnContainer column, out double ret) + public void Min(PrimitiveColumnContainer column, out double? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = double.MaxValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -1978,17 +2045,20 @@ public void Min(PrimitiveColumnContainer column, out double ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (double)(Math.Min(readOnlySpan[i], ret)); + hasValue = true; + value = (double)(Math.Min(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Min(PrimitiveColumnContainer column, IEnumerable rows, out double ret) + public void Min(PrimitiveColumnContainer column, IEnumerable rows, out double? ret) { - ret = double.MaxValue; + var value = double.MaxValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -2005,11 +2075,13 @@ public void Min(PrimitiveColumnContainer column, IEnumerable rows, maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (double)(Math.Min(readOnlySpan[(int)row], ret)); + value = (double)(Math.Min(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Product(PrimitiveColumnContainer column, out double ret) + public void Product(PrimitiveColumnContainer column, out double? ret) { ret = (double)1; for (int b = 0; b < column.Buffers.Count; b++) @@ -2020,7 +2092,7 @@ public void Product(PrimitiveColumnContainer column, out double ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (double)(readOnlySpan[i] * ret); } @@ -2028,9 +2100,9 @@ public void Product(PrimitiveColumnContainer column, out double ret) } } - public void Product(PrimitiveColumnContainer column, IEnumerable rows, out double ret) + public void Product(PrimitiveColumnContainer column, IEnumerable rows, out double? ret) { - ret = default; + double value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -2047,13 +2119,16 @@ public void Product(PrimitiveColumnContainer column, IEnumerable r maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((double)(readOnlySpan[(int)row] * ret)); + value = checked((double)(readOnlySpan[(int)row] * value)); } + + ret = value; } - public void Sum(PrimitiveColumnContainer column, out double ret) + public void Sum(PrimitiveColumnContainer column, out double? ret) { - ret = (double)0; + var value = (double)0; + var hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -2062,17 +2137,20 @@ public void Sum(PrimitiveColumnContainer column, out double ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (double)(readOnlySpan[i] + ret); + hasValue = true; + value = (double)(readOnlySpan[i] + value); } } } + + ret = hasValue ? value : null; } - public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out double ret) + public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out double? ret) { - ret = default; + double value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -2089,8 +2167,10 @@ public void Sum(PrimitiveColumnContainer column, IEnumerable rows, maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((double)(readOnlySpan[(int)row] + ret)); + value = checked((double)(readOnlySpan[(int)row] + value)); } + + ret = value; } public void Round(PrimitiveColumnContainer column) @@ -2149,7 +2229,7 @@ public void CumulativeMax(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (float)(Math.Max(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -2213,7 +2293,7 @@ public void CumulativeMin(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (float)(Math.Min(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -2277,7 +2357,7 @@ public void CumulativeProduct(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (float)(readOnlySpan[i] * ret); mutableSpan[i] = ret; @@ -2341,7 +2421,7 @@ public void CumulativeSum(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (float)(readOnlySpan[i] + ret); mutableSpan[i] = ret; @@ -2392,9 +2472,10 @@ public void CumulativeSum(PrimitiveColumnContainer column, IEnumerable column, out float ret) + public void Max(PrimitiveColumnContainer column, out float? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = float.MinValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -2403,17 +2484,20 @@ public void Max(PrimitiveColumnContainer column, out float ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (float)(Math.Max(readOnlySpan[i], ret)); + hasValue = true; + value = (float)(Math.Max(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Max(PrimitiveColumnContainer column, IEnumerable rows, out float ret) + public void Max(PrimitiveColumnContainer column, IEnumerable rows, out float? ret) { - ret = float.MinValue; + var value = float.MinValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -2430,13 +2514,16 @@ public void Max(PrimitiveColumnContainer column, IEnumerable rows, maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (float)(Math.Max(readOnlySpan[(int)row], ret)); + value = (float)(Math.Max(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Min(PrimitiveColumnContainer column, out float ret) + public void Min(PrimitiveColumnContainer column, out float? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = float.MaxValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -2445,17 +2532,20 @@ public void Min(PrimitiveColumnContainer column, out float ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (float)(Math.Min(readOnlySpan[i], ret)); + hasValue = true; + value = (float)(Math.Min(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Min(PrimitiveColumnContainer column, IEnumerable rows, out float ret) + public void Min(PrimitiveColumnContainer column, IEnumerable rows, out float? ret) { - ret = float.MaxValue; + var value = float.MaxValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -2472,11 +2562,13 @@ public void Min(PrimitiveColumnContainer column, IEnumerable rows, maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (float)(Math.Min(readOnlySpan[(int)row], ret)); + value = (float)(Math.Min(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Product(PrimitiveColumnContainer column, out float ret) + public void Product(PrimitiveColumnContainer column, out float? ret) { ret = (float)1; for (int b = 0; b < column.Buffers.Count; b++) @@ -2487,7 +2579,7 @@ public void Product(PrimitiveColumnContainer column, out float ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (float)(readOnlySpan[i] * ret); } @@ -2495,9 +2587,9 @@ public void Product(PrimitiveColumnContainer column, out float ret) } } - public void Product(PrimitiveColumnContainer column, IEnumerable rows, out float ret) + public void Product(PrimitiveColumnContainer column, IEnumerable rows, out float? ret) { - ret = default; + float value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -2514,13 +2606,16 @@ public void Product(PrimitiveColumnContainer column, IEnumerable ro maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((float)(readOnlySpan[(int)row] * ret)); + value = checked((float)(readOnlySpan[(int)row] * value)); } + + ret = value; } - public void Sum(PrimitiveColumnContainer column, out float ret) + public void Sum(PrimitiveColumnContainer column, out float? ret) { - ret = (float)0; + var value = (float)0; + var hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -2529,17 +2624,20 @@ public void Sum(PrimitiveColumnContainer column, out float ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (float)(readOnlySpan[i] + ret); + hasValue = true; + value = (float)(readOnlySpan[i] + value); } } } + + ret = hasValue ? value : null; } - public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out float ret) + public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out float? ret) { - ret = default; + float value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -2556,8 +2654,10 @@ public void Sum(PrimitiveColumnContainer column, IEnumerable rows, maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((float)(readOnlySpan[(int)row] + ret)); + value = checked((float)(readOnlySpan[(int)row] + value)); } + + ret = value; } public void Round(PrimitiveColumnContainer column) @@ -2616,7 +2716,7 @@ public void CumulativeMax(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (int)(Math.Max(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -2680,7 +2780,7 @@ public void CumulativeMin(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (int)(Math.Min(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -2744,7 +2844,7 @@ public void CumulativeProduct(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (int)(readOnlySpan[i] * ret); mutableSpan[i] = ret; @@ -2808,7 +2908,7 @@ public void CumulativeSum(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (int)(readOnlySpan[i] + ret); mutableSpan[i] = ret; @@ -2859,9 +2959,10 @@ public void CumulativeSum(PrimitiveColumnContainer column, IEnumerable column, out int ret) + public void Max(PrimitiveColumnContainer column, out int? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = int.MinValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -2870,17 +2971,20 @@ public void Max(PrimitiveColumnContainer column, out int ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (int)(Math.Max(readOnlySpan[i], ret)); + hasValue = true; + value = (int)(Math.Max(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Max(PrimitiveColumnContainer column, IEnumerable rows, out int ret) + public void Max(PrimitiveColumnContainer column, IEnumerable rows, out int? ret) { - ret = int.MinValue; + var value = int.MinValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -2897,13 +3001,16 @@ public void Max(PrimitiveColumnContainer column, IEnumerable rows, ou maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (int)(Math.Max(readOnlySpan[(int)row], ret)); + value = (int)(Math.Max(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Min(PrimitiveColumnContainer column, out int ret) + public void Min(PrimitiveColumnContainer column, out int? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = int.MaxValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -2912,17 +3019,20 @@ public void Min(PrimitiveColumnContainer column, out int ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (int)(Math.Min(readOnlySpan[i], ret)); + hasValue = true; + value = (int)(Math.Min(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Min(PrimitiveColumnContainer column, IEnumerable rows, out int ret) + public void Min(PrimitiveColumnContainer column, IEnumerable rows, out int? ret) { - ret = int.MaxValue; + var value = int.MaxValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -2939,11 +3049,13 @@ public void Min(PrimitiveColumnContainer column, IEnumerable rows, ou maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (int)(Math.Min(readOnlySpan[(int)row], ret)); + value = (int)(Math.Min(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Product(PrimitiveColumnContainer column, out int ret) + public void Product(PrimitiveColumnContainer column, out int? ret) { ret = (int)1; for (int b = 0; b < column.Buffers.Count; b++) @@ -2954,7 +3066,7 @@ public void Product(PrimitiveColumnContainer column, out int ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (int)(readOnlySpan[i] * ret); } @@ -2962,9 +3074,9 @@ public void Product(PrimitiveColumnContainer column, out int ret) } } - public void Product(PrimitiveColumnContainer column, IEnumerable rows, out int ret) + public void Product(PrimitiveColumnContainer column, IEnumerable rows, out int? ret) { - ret = default; + int value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -2981,13 +3093,16 @@ public void Product(PrimitiveColumnContainer column, IEnumerable rows maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((int)(readOnlySpan[(int)row] * ret)); + value = checked((int)(readOnlySpan[(int)row] * value)); } + + ret = value; } - public void Sum(PrimitiveColumnContainer column, out int ret) + public void Sum(PrimitiveColumnContainer column, out int? ret) { - ret = (int)0; + var value = (int)0; + var hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -2996,17 +3111,20 @@ public void Sum(PrimitiveColumnContainer column, out int ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (int)(readOnlySpan[i] + ret); + hasValue = true; + value = (int)(readOnlySpan[i] + value); } } } + + ret = hasValue ? value : null; } - public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out int ret) + public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out int? ret) { - ret = default; + int value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -3023,8 +3141,10 @@ public void Sum(PrimitiveColumnContainer column, IEnumerable rows, ou maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((int)(readOnlySpan[(int)row] + ret)); + value = checked((int)(readOnlySpan[(int)row] + value)); } + + ret = value; } public void Round(PrimitiveColumnContainer column) @@ -3083,7 +3203,7 @@ public void CumulativeMax(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (long)(Math.Max(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -3147,7 +3267,7 @@ public void CumulativeMin(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (long)(Math.Min(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -3211,7 +3331,7 @@ public void CumulativeProduct(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (long)(readOnlySpan[i] * ret); mutableSpan[i] = ret; @@ -3275,7 +3395,7 @@ public void CumulativeSum(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (long)(readOnlySpan[i] + ret); mutableSpan[i] = ret; @@ -3326,9 +3446,10 @@ public void CumulativeSum(PrimitiveColumnContainer column, IEnumerable column, out long ret) + public void Max(PrimitiveColumnContainer column, out long? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = long.MinValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -3337,17 +3458,20 @@ public void Max(PrimitiveColumnContainer column, out long ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (long)(Math.Max(readOnlySpan[i], ret)); + hasValue = true; + value = (long)(Math.Max(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Max(PrimitiveColumnContainer column, IEnumerable rows, out long ret) + public void Max(PrimitiveColumnContainer column, IEnumerable rows, out long? ret) { - ret = long.MinValue; + var value = long.MinValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -3364,13 +3488,16 @@ public void Max(PrimitiveColumnContainer column, IEnumerable rows, o maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (long)(Math.Max(readOnlySpan[(int)row], ret)); + value = (long)(Math.Max(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Min(PrimitiveColumnContainer column, out long ret) + public void Min(PrimitiveColumnContainer column, out long? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = long.MaxValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -3379,17 +3506,20 @@ public void Min(PrimitiveColumnContainer column, out long ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (long)(Math.Min(readOnlySpan[i], ret)); + hasValue = true; + value = (long)(Math.Min(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Min(PrimitiveColumnContainer column, IEnumerable rows, out long ret) + public void Min(PrimitiveColumnContainer column, IEnumerable rows, out long? ret) { - ret = long.MaxValue; + var value = long.MaxValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -3406,11 +3536,13 @@ public void Min(PrimitiveColumnContainer column, IEnumerable rows, o maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (long)(Math.Min(readOnlySpan[(int)row], ret)); + value = (long)(Math.Min(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Product(PrimitiveColumnContainer column, out long ret) + public void Product(PrimitiveColumnContainer column, out long? ret) { ret = (long)1; for (int b = 0; b < column.Buffers.Count; b++) @@ -3421,7 +3553,7 @@ public void Product(PrimitiveColumnContainer column, out long ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (long)(readOnlySpan[i] * ret); } @@ -3429,9 +3561,9 @@ public void Product(PrimitiveColumnContainer column, out long ret) } } - public void Product(PrimitiveColumnContainer column, IEnumerable rows, out long ret) + public void Product(PrimitiveColumnContainer column, IEnumerable rows, out long? ret) { - ret = default; + long value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -3448,13 +3580,16 @@ public void Product(PrimitiveColumnContainer column, IEnumerable row maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((long)(readOnlySpan[(int)row] * ret)); + value = checked((long)(readOnlySpan[(int)row] * value)); } + + ret = value; } - public void Sum(PrimitiveColumnContainer column, out long ret) + public void Sum(PrimitiveColumnContainer column, out long? ret) { - ret = (long)0; + var value = (long)0; + var hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -3463,17 +3598,20 @@ public void Sum(PrimitiveColumnContainer column, out long ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (long)(readOnlySpan[i] + ret); + hasValue = true; + value = (long)(readOnlySpan[i] + value); } } } + + ret = hasValue ? value : null; } - public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out long ret) + public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out long? ret) { - ret = default; + long value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -3490,8 +3628,10 @@ public void Sum(PrimitiveColumnContainer column, IEnumerable rows, o maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((long)(readOnlySpan[(int)row] + ret)); + value = checked((long)(readOnlySpan[(int)row] + value)); } + + ret = value; } public void Round(PrimitiveColumnContainer column) @@ -3550,7 +3690,7 @@ public void CumulativeMax(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (sbyte)(Math.Max(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -3614,7 +3754,7 @@ public void CumulativeMin(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (sbyte)(Math.Min(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -3678,7 +3818,7 @@ public void CumulativeProduct(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (sbyte)(readOnlySpan[i] * ret); mutableSpan[i] = ret; @@ -3742,7 +3882,7 @@ public void CumulativeSum(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (sbyte)(readOnlySpan[i] + ret); mutableSpan[i] = ret; @@ -3793,9 +3933,10 @@ public void CumulativeSum(PrimitiveColumnContainer column, IEnumerable column, out sbyte ret) + public void Max(PrimitiveColumnContainer column, out sbyte? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = sbyte.MinValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -3804,17 +3945,20 @@ public void Max(PrimitiveColumnContainer column, out sbyte ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (sbyte)(Math.Max(readOnlySpan[i], ret)); + hasValue = true; + value = (sbyte)(Math.Max(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Max(PrimitiveColumnContainer column, IEnumerable rows, out sbyte ret) + public void Max(PrimitiveColumnContainer column, IEnumerable rows, out sbyte? ret) { - ret = sbyte.MinValue; + var value = sbyte.MinValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -3831,13 +3975,16 @@ public void Max(PrimitiveColumnContainer column, IEnumerable rows, maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (sbyte)(Math.Max(readOnlySpan[(int)row], ret)); + value = (sbyte)(Math.Max(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Min(PrimitiveColumnContainer column, out sbyte ret) + public void Min(PrimitiveColumnContainer column, out sbyte? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = sbyte.MaxValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -3846,17 +3993,20 @@ public void Min(PrimitiveColumnContainer column, out sbyte ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (sbyte)(Math.Min(readOnlySpan[i], ret)); + hasValue = true; + value = (sbyte)(Math.Min(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Min(PrimitiveColumnContainer column, IEnumerable rows, out sbyte ret) + public void Min(PrimitiveColumnContainer column, IEnumerable rows, out sbyte? ret) { - ret = sbyte.MaxValue; + var value = sbyte.MaxValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -3873,11 +4023,13 @@ public void Min(PrimitiveColumnContainer column, IEnumerable rows, maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (sbyte)(Math.Min(readOnlySpan[(int)row], ret)); + value = (sbyte)(Math.Min(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Product(PrimitiveColumnContainer column, out sbyte ret) + public void Product(PrimitiveColumnContainer column, out sbyte? ret) { ret = (sbyte)1; for (int b = 0; b < column.Buffers.Count; b++) @@ -3888,7 +4040,7 @@ public void Product(PrimitiveColumnContainer column, out sbyte ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (sbyte)(readOnlySpan[i] * ret); } @@ -3896,9 +4048,9 @@ public void Product(PrimitiveColumnContainer column, out sbyte ret) } } - public void Product(PrimitiveColumnContainer column, IEnumerable rows, out sbyte ret) + public void Product(PrimitiveColumnContainer column, IEnumerable rows, out sbyte? ret) { - ret = default; + sbyte value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -3915,13 +4067,16 @@ public void Product(PrimitiveColumnContainer column, IEnumerable ro maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((sbyte)(readOnlySpan[(int)row] * ret)); + value = checked((sbyte)(readOnlySpan[(int)row] * value)); } + + ret = value; } - public void Sum(PrimitiveColumnContainer column, out sbyte ret) + public void Sum(PrimitiveColumnContainer column, out sbyte? ret) { - ret = (sbyte)0; + var value = (sbyte)0; + var hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -3930,17 +4085,20 @@ public void Sum(PrimitiveColumnContainer column, out sbyte ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (sbyte)(readOnlySpan[i] + ret); + hasValue = true; + value = (sbyte)(readOnlySpan[i] + value); } } } + + ret = hasValue ? value : null; } - public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out sbyte ret) + public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out sbyte? ret) { - ret = default; + sbyte value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -3957,8 +4115,10 @@ public void Sum(PrimitiveColumnContainer column, IEnumerable rows, maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((sbyte)(readOnlySpan[(int)row] + ret)); + value = checked((sbyte)(readOnlySpan[(int)row] + value)); } + + ret = value; } public void Round(PrimitiveColumnContainer column) @@ -4017,7 +4177,7 @@ public void CumulativeMax(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (short)(Math.Max(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -4081,7 +4241,7 @@ public void CumulativeMin(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (short)(Math.Min(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -4145,7 +4305,7 @@ public void CumulativeProduct(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (short)(readOnlySpan[i] * ret); mutableSpan[i] = ret; @@ -4209,7 +4369,7 @@ public void CumulativeSum(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (short)(readOnlySpan[i] + ret); mutableSpan[i] = ret; @@ -4260,9 +4420,10 @@ public void CumulativeSum(PrimitiveColumnContainer column, IEnumerable column, out short ret) + public void Max(PrimitiveColumnContainer column, out short? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = short.MinValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -4271,17 +4432,20 @@ public void Max(PrimitiveColumnContainer column, out short ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (short)(Math.Max(readOnlySpan[i], ret)); + hasValue = true; + value = (short)(Math.Max(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Max(PrimitiveColumnContainer column, IEnumerable rows, out short ret) + public void Max(PrimitiveColumnContainer column, IEnumerable rows, out short? ret) { - ret = short.MinValue; + var value = short.MinValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -4298,13 +4462,16 @@ public void Max(PrimitiveColumnContainer column, IEnumerable rows, maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (short)(Math.Max(readOnlySpan[(int)row], ret)); + value = (short)(Math.Max(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Min(PrimitiveColumnContainer column, out short ret) + public void Min(PrimitiveColumnContainer column, out short? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = short.MaxValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -4313,17 +4480,20 @@ public void Min(PrimitiveColumnContainer column, out short ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (short)(Math.Min(readOnlySpan[i], ret)); + hasValue = true; + value = (short)(Math.Min(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Min(PrimitiveColumnContainer column, IEnumerable rows, out short ret) + public void Min(PrimitiveColumnContainer column, IEnumerable rows, out short? ret) { - ret = short.MaxValue; + var value = short.MaxValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -4340,11 +4510,13 @@ public void Min(PrimitiveColumnContainer column, IEnumerable rows, maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (short)(Math.Min(readOnlySpan[(int)row], ret)); + value = (short)(Math.Min(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Product(PrimitiveColumnContainer column, out short ret) + public void Product(PrimitiveColumnContainer column, out short? ret) { ret = (short)1; for (int b = 0; b < column.Buffers.Count; b++) @@ -4355,7 +4527,7 @@ public void Product(PrimitiveColumnContainer column, out short ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (short)(readOnlySpan[i] * ret); } @@ -4363,9 +4535,9 @@ public void Product(PrimitiveColumnContainer column, out short ret) } } - public void Product(PrimitiveColumnContainer column, IEnumerable rows, out short ret) + public void Product(PrimitiveColumnContainer column, IEnumerable rows, out short? ret) { - ret = default; + short value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -4382,13 +4554,16 @@ public void Product(PrimitiveColumnContainer column, IEnumerable ro maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((short)(readOnlySpan[(int)row] * ret)); + value = checked((short)(readOnlySpan[(int)row] * value)); } + + ret = value; } - public void Sum(PrimitiveColumnContainer column, out short ret) + public void Sum(PrimitiveColumnContainer column, out short? ret) { - ret = (short)0; + var value = (short)0; + var hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -4397,17 +4572,20 @@ public void Sum(PrimitiveColumnContainer column, out short ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (short)(readOnlySpan[i] + ret); + hasValue = true; + value = (short)(readOnlySpan[i] + value); } } } + + ret = hasValue ? value : null; } - public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out short ret) + public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out short? ret) { - ret = default; + short value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -4424,8 +4602,10 @@ public void Sum(PrimitiveColumnContainer column, IEnumerable rows, maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((short)(readOnlySpan[(int)row] + ret)); + value = checked((short)(readOnlySpan[(int)row] + value)); } + + ret = value; } public void Round(PrimitiveColumnContainer column) @@ -4484,7 +4664,7 @@ public void CumulativeMax(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (uint)(Math.Max(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -4548,7 +4728,7 @@ public void CumulativeMin(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (uint)(Math.Min(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -4612,7 +4792,7 @@ public void CumulativeProduct(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (uint)(readOnlySpan[i] * ret); mutableSpan[i] = ret; @@ -4676,7 +4856,7 @@ public void CumulativeSum(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (uint)(readOnlySpan[i] + ret); mutableSpan[i] = ret; @@ -4727,9 +4907,10 @@ public void CumulativeSum(PrimitiveColumnContainer column, IEnumerable column, out uint ret) + public void Max(PrimitiveColumnContainer column, out uint? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = uint.MinValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -4738,17 +4919,20 @@ public void Max(PrimitiveColumnContainer column, out uint ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (uint)(Math.Max(readOnlySpan[i], ret)); + hasValue = true; + value = (uint)(Math.Max(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Max(PrimitiveColumnContainer column, IEnumerable rows, out uint ret) + public void Max(PrimitiveColumnContainer column, IEnumerable rows, out uint? ret) { - ret = uint.MinValue; + var value = uint.MinValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -4765,13 +4949,16 @@ public void Max(PrimitiveColumnContainer column, IEnumerable rows, o maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (uint)(Math.Max(readOnlySpan[(int)row], ret)); + value = (uint)(Math.Max(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Min(PrimitiveColumnContainer column, out uint ret) + public void Min(PrimitiveColumnContainer column, out uint? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = uint.MaxValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -4780,17 +4967,20 @@ public void Min(PrimitiveColumnContainer column, out uint ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (uint)(Math.Min(readOnlySpan[i], ret)); + hasValue = true; + value = (uint)(Math.Min(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Min(PrimitiveColumnContainer column, IEnumerable rows, out uint ret) + public void Min(PrimitiveColumnContainer column, IEnumerable rows, out uint? ret) { - ret = uint.MaxValue; + var value = uint.MaxValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -4807,11 +4997,13 @@ public void Min(PrimitiveColumnContainer column, IEnumerable rows, o maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (uint)(Math.Min(readOnlySpan[(int)row], ret)); + value = (uint)(Math.Min(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Product(PrimitiveColumnContainer column, out uint ret) + public void Product(PrimitiveColumnContainer column, out uint? ret) { ret = (uint)1; for (int b = 0; b < column.Buffers.Count; b++) @@ -4822,7 +5014,7 @@ public void Product(PrimitiveColumnContainer column, out uint ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (uint)(readOnlySpan[i] * ret); } @@ -4830,9 +5022,9 @@ public void Product(PrimitiveColumnContainer column, out uint ret) } } - public void Product(PrimitiveColumnContainer column, IEnumerable rows, out uint ret) + public void Product(PrimitiveColumnContainer column, IEnumerable rows, out uint? ret) { - ret = default; + uint value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -4849,13 +5041,16 @@ public void Product(PrimitiveColumnContainer column, IEnumerable row maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((uint)(readOnlySpan[(int)row] * ret)); + value = checked((uint)(readOnlySpan[(int)row] * value)); } + + ret = value; } - public void Sum(PrimitiveColumnContainer column, out uint ret) + public void Sum(PrimitiveColumnContainer column, out uint? ret) { - ret = (uint)0; + var value = (uint)0; + var hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -4864,17 +5059,20 @@ public void Sum(PrimitiveColumnContainer column, out uint ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (uint)(readOnlySpan[i] + ret); + hasValue = true; + value = (uint)(readOnlySpan[i] + value); } } } + + ret = hasValue ? value : null; } - public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out uint ret) + public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out uint? ret) { - ret = default; + uint value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -4891,8 +5089,10 @@ public void Sum(PrimitiveColumnContainer column, IEnumerable rows, o maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((uint)(readOnlySpan[(int)row] + ret)); + value = checked((uint)(readOnlySpan[(int)row] + value)); } + + ret = value; } public void Round(PrimitiveColumnContainer column) @@ -4951,7 +5151,7 @@ public void CumulativeMax(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (ulong)(Math.Max(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -5015,7 +5215,7 @@ public void CumulativeMin(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (ulong)(Math.Min(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -5079,7 +5279,7 @@ public void CumulativeProduct(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (ulong)(readOnlySpan[i] * ret); mutableSpan[i] = ret; @@ -5143,7 +5343,7 @@ public void CumulativeSum(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (ulong)(readOnlySpan[i] + ret); mutableSpan[i] = ret; @@ -5194,9 +5394,10 @@ public void CumulativeSum(PrimitiveColumnContainer column, IEnumerable column, out ulong ret) + public void Max(PrimitiveColumnContainer column, out ulong? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = ulong.MinValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -5205,17 +5406,20 @@ public void Max(PrimitiveColumnContainer column, out ulong ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (ulong)(Math.Max(readOnlySpan[i], ret)); + hasValue = true; + value = (ulong)(Math.Max(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Max(PrimitiveColumnContainer column, IEnumerable rows, out ulong ret) + public void Max(PrimitiveColumnContainer column, IEnumerable rows, out ulong? ret) { - ret = ulong.MinValue; + var value = ulong.MinValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -5232,13 +5436,16 @@ public void Max(PrimitiveColumnContainer column, IEnumerable rows, maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (ulong)(Math.Max(readOnlySpan[(int)row], ret)); + value = (ulong)(Math.Max(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Min(PrimitiveColumnContainer column, out ulong ret) + public void Min(PrimitiveColumnContainer column, out ulong? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = ulong.MaxValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -5247,17 +5454,20 @@ public void Min(PrimitiveColumnContainer column, out ulong ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (ulong)(Math.Min(readOnlySpan[i], ret)); + hasValue = true; + value = (ulong)(Math.Min(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Min(PrimitiveColumnContainer column, IEnumerable rows, out ulong ret) + public void Min(PrimitiveColumnContainer column, IEnumerable rows, out ulong? ret) { - ret = ulong.MaxValue; + var value = ulong.MaxValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -5274,11 +5484,13 @@ public void Min(PrimitiveColumnContainer column, IEnumerable rows, maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (ulong)(Math.Min(readOnlySpan[(int)row], ret)); + value = (ulong)(Math.Min(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Product(PrimitiveColumnContainer column, out ulong ret) + public void Product(PrimitiveColumnContainer column, out ulong? ret) { ret = (ulong)1; for (int b = 0; b < column.Buffers.Count; b++) @@ -5289,7 +5501,7 @@ public void Product(PrimitiveColumnContainer column, out ulong ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (ulong)(readOnlySpan[i] * ret); } @@ -5297,9 +5509,9 @@ public void Product(PrimitiveColumnContainer column, out ulong ret) } } - public void Product(PrimitiveColumnContainer column, IEnumerable rows, out ulong ret) + public void Product(PrimitiveColumnContainer column, IEnumerable rows, out ulong? ret) { - ret = default; + ulong value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -5316,13 +5528,16 @@ public void Product(PrimitiveColumnContainer column, IEnumerable ro maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((ulong)(readOnlySpan[(int)row] * ret)); + value = checked((ulong)(readOnlySpan[(int)row] * value)); } + + ret = value; } - public void Sum(PrimitiveColumnContainer column, out ulong ret) + public void Sum(PrimitiveColumnContainer column, out ulong? ret) { - ret = (ulong)0; + var value = (ulong)0; + var hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -5331,17 +5546,20 @@ public void Sum(PrimitiveColumnContainer column, out ulong ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (ulong)(readOnlySpan[i] + ret); + hasValue = true; + value = (ulong)(readOnlySpan[i] + value); } } } + + ret = hasValue ? value : null; } - public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out ulong ret) + public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out ulong? ret) { - ret = default; + ulong value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -5358,8 +5576,10 @@ public void Sum(PrimitiveColumnContainer column, IEnumerable rows, maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((ulong)(readOnlySpan[(int)row] + ret)); + value = checked((ulong)(readOnlySpan[(int)row] + value)); } + + ret = value; } public void Round(PrimitiveColumnContainer column) @@ -5418,7 +5638,7 @@ public void CumulativeMax(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (ushort)(Math.Max(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -5482,7 +5702,7 @@ public void CumulativeMin(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (ushort)(Math.Min(readOnlySpan[i], ret)); mutableSpan[i] = ret; @@ -5546,7 +5766,7 @@ public void CumulativeProduct(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (ushort)(readOnlySpan[i] * ret); mutableSpan[i] = ret; @@ -5610,7 +5830,7 @@ public void CumulativeSum(PrimitiveColumnContainer column) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (ushort)(readOnlySpan[i] + ret); mutableSpan[i] = ret; @@ -5661,9 +5881,10 @@ public void CumulativeSum(PrimitiveColumnContainer column, IEnumerable column, out ushort ret) + public void Max(PrimitiveColumnContainer column, out ushort? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = ushort.MinValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -5672,17 +5893,20 @@ public void Max(PrimitiveColumnContainer column, out ushort ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (ushort)(Math.Max(readOnlySpan[i], ret)); + hasValue = true; + value = (ushort)(Math.Max(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Max(PrimitiveColumnContainer column, IEnumerable rows, out ushort ret) + public void Max(PrimitiveColumnContainer column, IEnumerable rows, out ushort? ret) { - ret = ushort.MinValue; + var value = ushort.MinValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -5699,13 +5923,16 @@ public void Max(PrimitiveColumnContainer column, IEnumerable rows, maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (ushort)(Math.Max(readOnlySpan[(int)row], ret)); + value = (ushort)(Math.Max(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Min(PrimitiveColumnContainer column, out ushort ret) + public void Min(PrimitiveColumnContainer column, out ushort? ret) { - ret = column.Buffers[0].ReadOnlySpan[0]; + var value = ushort.MaxValue; + bool hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -5714,17 +5941,20 @@ public void Min(PrimitiveColumnContainer column, out ushort ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (ushort)(Math.Min(readOnlySpan[i], ret)); + hasValue = true; + value = (ushort)(Math.Min(readOnlySpan[i], value)); } } } + + ret = hasValue ? value : null; } - public void Min(PrimitiveColumnContainer column, IEnumerable rows, out ushort ret) + public void Min(PrimitiveColumnContainer column, IEnumerable rows, out ushort? ret) { - ret = ushort.MaxValue; + var value = ushort.MaxValue; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -5741,11 +5971,13 @@ public void Min(PrimitiveColumnContainer column, IEnumerable rows, maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = (ushort)(Math.Min(readOnlySpan[(int)row], ret)); + value = (ushort)(Math.Min(readOnlySpan[(int)row], value)); } + + ret = value; } - public void Product(PrimitiveColumnContainer column, out ushort ret) + public void Product(PrimitiveColumnContainer column, out ushort? ret) { ret = (ushort)1; for (int b = 0; b < column.Buffers.Count; b++) @@ -5756,7 +5988,7 @@ public void Product(PrimitiveColumnContainer column, out ushort ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { ret = (ushort)(readOnlySpan[i] * ret); } @@ -5764,9 +5996,9 @@ public void Product(PrimitiveColumnContainer column, out ushort ret) } } - public void Product(PrimitiveColumnContainer column, IEnumerable rows, out ushort ret) + public void Product(PrimitiveColumnContainer column, IEnumerable rows, out ushort? ret) { - ret = default; + ushort value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -5783,13 +6015,16 @@ public void Product(PrimitiveColumnContainer column, IEnumerable r maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((ushort)(readOnlySpan[(int)row] * ret)); + value = checked((ushort)(readOnlySpan[(int)row] * value)); } + + ret = value; } - public void Sum(PrimitiveColumnContainer column, out ushort ret) + public void Sum(PrimitiveColumnContainer column, out ushort? ret) { - ret = (ushort)0; + var value = (ushort)0; + var hasValue = false; for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -5798,17 +6033,20 @@ public void Sum(PrimitiveColumnContainer column, out ushort ret) for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { - ret = (ushort)(readOnlySpan[i] + ret); + hasValue = true; + value = (ushort)(readOnlySpan[i] + value); } } } + + ret = hasValue ? value : null; } - public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out ushort ret) + public void Sum(PrimitiveColumnContainer column, IEnumerable rows, out ushort? ret) { - ret = default; + ushort value = default; var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; long maxRange = ReadOnlyDataFrameBuffer.MaxCapacity; @@ -5825,8 +6063,10 @@ public void Sum(PrimitiveColumnContainer column, IEnumerable rows, maxRange = checked((bufferIndex + 1) * maxCapacity); } row -= minRange; - ret = checked((ushort)(readOnlySpan[(int)row] + ret)); + value = checked((ushort)(readOnlySpan[(int)row] + value)); } + + ret = value; } public void Round(PrimitiveColumnContainer column) diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.tt index 7749369ecc..4bea44c3f3 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.tt +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.tt @@ -29,9 +29,9 @@ namespace Microsoft.Data.Analysis <# } else if (compMethod.MethodType == MethodType.ElementwiseComputation && compMethod.HasReturnValue == true) {#> void <#=compMethod.MethodName#>(PrimitiveColumnContainer column, out T ret); <# } else if (compMethod.MethodType == MethodType.Reduction && compMethod.IsNumeric == true && compMethod.SupportsRowSubsets == true) { #> - void <#=compMethod.MethodName#>(PrimitiveColumnContainer column, IEnumerable rows, out T ret); + void <#=compMethod.MethodName#>(PrimitiveColumnContainer column, IEnumerable rows, out T? ret); <# } else if (compMethod.MethodType == MethodType.Reduction && compMethod.IsNumeric == true) { #> - void <#=compMethod.MethodName#>(PrimitiveColumnContainer column, out T ret); + void <#=compMethod.MethodName#>(PrimitiveColumnContainer column, out T? ret); <# } else { #> void <#=compMethod.MethodName#>(PrimitiveColumnContainer column, out bool ret); <# } #> @@ -78,9 +78,9 @@ namespace Microsoft.Data.Analysis <# } else if (method.MethodType == MethodType.ElementwiseComputation && method.HasReturnValue == true) {#> public void <#=method.MethodName#>(PrimitiveColumnContainer<<#=type.TypeName#>> column, out <#=type.TypeName#> ret) <# } else if (method.MethodType == MethodType.Reduction && method.IsNumeric == true && method.SupportsRowSubsets == true) { #> - public void <#=method.MethodName#>(PrimitiveColumnContainer<<#=type.TypeName#>> column, IEnumerable rows, out <#=type.TypeName#> ret) + public void <#=method.MethodName#>(PrimitiveColumnContainer<<#=type.TypeName#>> column, IEnumerable rows, out <#=type.TypeName#>? ret) <# } else if (method.MethodType == MethodType.Reduction && method.IsNumeric == true) { #> - public void <#=method.MethodName#>(PrimitiveColumnContainer<<#=type.TypeName#>> column, out <#=type.TypeName#> ret) + public void <#=method.MethodName#>(PrimitiveColumnContainer<<#=type.TypeName#>> column, out <#=type.TypeName#>? ret) <# } else { #> public void <#=method.MethodName#>(PrimitiveColumnContainer<<#=type.TypeName#>> column, out bool ret) <# } #> @@ -90,11 +90,11 @@ namespace Microsoft.Data.Analysis <# } else { #> <# if ((method.MethodName == "Max" || method.MethodName == "Min" || method.MethodName == "Product" || method.MethodName == "Sum") && method.SupportsRowSubsets == true) { #> <# if (method.MethodName == "Max") { #> - ret = <#=type.TypeName#>.MinValue; + var value = <#=type.TypeName#>.MinValue; <# } else if (method.MethodName == "Min") { #> - ret = <#=type.TypeName#>.MaxValue; + var value = <#=type.TypeName#>.MaxValue; <# } else { #> - ret = default; + <#=type.TypeName#> value = default; <# } #> var readOnlySpan = column.Buffers[0].ReadOnlySpan; long minRange = 0; @@ -113,18 +113,20 @@ namespace Microsoft.Data.Analysis } row -= minRange; <# if (method.MethodName == "Max") { #> - ret = (<#=type.TypeName#>)(Math.Max(readOnlySpan[(int)row], ret)); + value = (<#=type.TypeName#>)(Math.Max(readOnlySpan[(int)row], value)); <# } #> <# if (method.MethodName == "Min") { #> - ret = (<#=type.TypeName#>)(Math.Min(readOnlySpan[(int)row], ret)); + value = (<#=type.TypeName#>)(Math.Min(readOnlySpan[(int)row], value)); <# } #> <# if (method.MethodName == "Product") { #> - ret = checked((<#=type.TypeName#>)(readOnlySpan[(int)row] * ret)); + value = checked((<#=type.TypeName#>)(readOnlySpan[(int)row] * value)); <# } #> <# if (method.MethodName == "Sum") { #> - ret = checked((<#=type.TypeName#>)(readOnlySpan[(int)row] + ret)); + value = checked((<#=type.TypeName#>)(readOnlySpan[(int)row] + value)); <# } #> } + + ret = value; <# } else if ((method.MethodName == "CumulativeMax" || method.MethodName == "CumulativeMin" || method.MethodName == "CumulativeProduct" || method.MethodName == "CumulativeSum") && method.SupportsRowSubsets == true) { #> <# if (method.MethodName == "CumulativeMax") { #> var ret = <#=type.TypeName#>.MinValue; @@ -183,8 +185,12 @@ namespace Microsoft.Data.Analysis <# } else if (method.MethodName == "CumulativeMax" || method.MethodName == "CumulativeMin" || method.MethodName == "CumulativeProduct" || method.MethodName == "CumulativeSum" || method.MethodName == "Max" || method.MethodName == "Min" || method.MethodName == "Product" || method.MethodName == "Sum") { #> <# if (method.MethodName == "CumulativeMax" || method.MethodName == "CumulativeMin") { #> var ret = column.Buffers[0].ReadOnlySpan[0]; -<# } else if ((method.MethodName == "Max" || method.MethodName == "Min") && method.SupportsRowSubsets == false) { #> - ret = column.Buffers[0].ReadOnlySpan[0]; +<# } else if (method.MethodName == "Max" && method.SupportsRowSubsets == false) { #> + var value = <#=type.TypeName#>.MinValue; + bool hasValue = false; +<# } else if (method.MethodName == "Min" && method.SupportsRowSubsets == false) { #> + var value = <#=type.TypeName#>.MaxValue; + bool hasValue = false; <# } else if (method.MethodName == "CumulativeProduct") { #> var ret = (<#=type.TypeName#>)1; <# } else if (method.MethodName =="Product" && method.SupportsRowSubsets == false) { #> @@ -192,7 +198,8 @@ namespace Microsoft.Data.Analysis <# } else if (method.MethodName =="CumulativeSum") { #> var ret = (<#=type.TypeName#>)0; <# } else if (method.SupportsRowSubsets == false) { #> - ret = (<#=type.TypeName#>)0; + var value = (<#=type.TypeName#>)0; + var hasValue = false; <# } #> for (int b = 0; b < column.Buffers.Count; b++) { @@ -206,7 +213,7 @@ namespace Microsoft.Data.Analysis for (int i = 0; i < readOnlySpan.Length; i++) { - if (column.IsValid(readOnlyBitMapSpan, i)) + if (BitmapHelper.IsValid(readOnlyBitMapSpan, i)) { <# if (method.MethodName == "CumulativeMax") { #> ret = (<#=type.TypeName#>)(Math.Max(readOnlySpan[i], ret)); @@ -225,23 +232,32 @@ namespace Microsoft.Data.Analysis mutableSpan[i] = ret; <# } #> <# if (method.MethodName == "Max") { #> - ret = (<#=type.TypeName#>)(Math.Max(readOnlySpan[i], ret)); + hasValue = true; + value = (<#=type.TypeName#>)(Math.Max(readOnlySpan[i], value)); <# } #> <# if (method.MethodName == "Min") { #> - ret = (<#=type.TypeName#>)(Math.Min(readOnlySpan[i], ret)); + hasValue = true; + value = (<#=type.TypeName#>)(Math.Min(readOnlySpan[i], value)); <# } #> <# if (method.MethodName == "Product") { #> ret = (<#=type.TypeName#>)(readOnlySpan[i] * ret); <# } #> <# if (method.MethodName == "Sum") { #> - ret = (<#=type.TypeName#>)(readOnlySpan[i] + ret); + hasValue = true; + value = (<#=type.TypeName#>)(readOnlySpan[i] + value); <# } #> } } <# if (method.MethodName == "CumulativeMax" || method.MethodName == "CumulativeMin" || method.MethodName == "CumulativeProduct" || method.MethodName == "CumulativeSum") { #> column.Buffers[b] = mutableBuffer; -<# } #> } +<# } else if (method.MethodName == "Product") { #> + } +<# } else { #> + } + + ret = hasValue ? value : null; +<# } #> <# } else if (method.MethodType == MethodType.ElementwiseComputation && method.Operator != null) { #> for (int b = 0; b < column.Buffers.Count; b++) { diff --git a/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs b/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs index 8e7b1ea37f..35bf334d6a 100644 --- a/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs +++ b/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs @@ -1173,6 +1173,72 @@ public void TestComputationsIncludingDateTime() } } + [Fact] + public void TestIntComputations_MaxMin_WithNulls() + { + var column = new Int32DataFrameColumn("Int", new int?[] + { + null, + 2, + 1, + 4, + 3, + null + }); + + Assert.Equal(1, column.Min()); + Assert.Equal(4, column.Max()); + } + + [Fact] + public void TestIntSum_OnColumnWithNullsOnly() + { + var column = new Int32DataFrameColumn("Int", new int?[] { null, null }); + Assert.Null(column.Sum()); + } + + [Fact] + public void TestIntSum_OnEmptyColumn() + { + var column = new Int32DataFrameColumn("Int"); + Assert.Null(column.Sum()); + } + + [Fact] + public void TestIntComputations_MaxMin_OnEmptyColumn() + { + var column = new Int32DataFrameColumn("Int"); + + Assert.Null(column.Min()); + Assert.Null(column.Max()); + } + + [Fact] + public void TestDateTimeComputations_MaxMin_OnEmptyColumn() + { + var column = new DateTimeDataFrameColumn("DateTime"); + + Assert.Null(column.Min()); + Assert.Null(column.Max()); + } + + [Fact] + public void TestDateTimeComputations_MaxMin_WithNulls() + { + var dateTimeColumn = new DateTimeDataFrameColumn("DateTime", new DateTime?[] + { + null, + new DateTime(2022, 1, 1), + new DateTime(2020, 1, 1), + new DateTime(2023, 1, 1), + new DateTime(2021, 1, 1), + null + }); + + Assert.Equal(new DateTime(2020, 1, 1), dateTimeColumn.Min()); + Assert.Equal(new DateTime(2023, 1, 1), dateTimeColumn.Max()); + } + [Theory] [InlineData(5, 10)] [InlineData(-15, 10)] From 321158d13871133fe08694ae439f39f3f9b2c0e6 Mon Sep 17 00:00:00 2001 From: Aleksei Smirnov Date: Tue, 11 Jul 2023 23:07:57 +0300 Subject: [PATCH 11/18] Clean DataFrame meaningless code (#6761) --- src/Microsoft.Data.Analysis/DataFrame.IO.cs | 4 --- .../PrimitiveColumnContainer.cs | 30 +------------------ 2 files changed, 1 insertion(+), 33 deletions(-) diff --git a/src/Microsoft.Data.Analysis/DataFrame.IO.cs b/src/Microsoft.Data.Analysis/DataFrame.IO.cs index 4a57397588..44448da008 100644 --- a/src/Microsoft.Data.Analysis/DataFrame.IO.cs +++ b/src/Microsoft.Data.Analysis/DataFrame.IO.cs @@ -127,10 +127,6 @@ public static DataFrame LoadFrom(IEnumerable> vals, IList<(string, foreach (var items in vals) { - for (var c = 0; c < items.Count; c++) - { - items[c] = items[c]; - } res.Append(items, inPlace: true); } diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs index 745d1800e9..1e37ac2206 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs @@ -44,35 +44,6 @@ internal partial class PrimitiveColumnContainer : IEnumerable // Need a way to differentiate between columns initialized with default values and those with null values in SetValidityBit internal bool _modifyNullCountWhileIndexing = true; - public PrimitiveColumnContainer(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); - NullBitMapBuffers.Add(new DataFrameBuffer()); - } - else - { - curBuffer = (DataFrameBuffer)Buffers[Buffers.Count - 1]; - } - for (long i = 0; i < length; i++) - { - if (curBuffer.Length == ReadOnlyDataFrameBuffer.MaxCapacity) - { - curBuffer = new DataFrameBuffer(); - Buffers.Add(curBuffer); - NullBitMapBuffers.Add(new DataFrameBuffer()); - } - curBuffer.Append(values[i]); - SetValidityBit(Length, true); - Length++; - } - } - public PrimitiveColumnContainer(IEnumerable values) { values = values ?? throw new ArgumentNullException(nameof(values)); @@ -81,6 +52,7 @@ public PrimitiveColumnContainer(IEnumerable values) Append(value); } } + public PrimitiveColumnContainer(IEnumerable values) { values = values ?? throw new ArgumentNullException(nameof(values)); From 9796936ed67136aa919b10b6c1be9ecac0bbb300 Mon Sep 17 00:00:00 2001 From: Aleksei Smirnov Date: Thu, 13 Jul 2023 14:31:19 +0300 Subject: [PATCH 12/18] Change methods signature generation --- .../ColumnArithmeticTemplate.ttinclude | 16 +- .../DataFrameColumn.BinaryOperations.tt | 6 + ...imitiveColumnContainer.BinaryOperations.cs | 74 ++-- ...imitiveColumnContainer.BinaryOperations.tt | 21 +- ...rimitiveDataFrameColumn.BinaryOperators.cs | 2 + ...rimitiveDataFrameColumn.BinaryOperators.tt | 2 + .../PrimitiveDataFrameColumnArithmetic.cs | 360 +++++++++--------- .../PrimitiveDataFrameColumnArithmetic.tt | 4 +- 8 files changed, 232 insertions(+), 253 deletions(-) diff --git a/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude b/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude index bb31da6a94..c9a89655fd 100644 --- a/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude +++ b/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude @@ -354,13 +354,7 @@ { return GetColumnSpecificMethodComments().Replace(" an", " a reversed"); } - - public string GetMethodSignature(string columnType, string genericType) - { - var arguments = GetMethodArguments(columnType, genericType); - return $"void {MethodName}({arguments})"; - } - + public string GetInvertedMethodSignatureForBinaryScalarsOps(string columnType, string genericType) { var arguments = GetInvertedMethodArguments(columnType, genericType); @@ -408,13 +402,13 @@ case MethodType.BinaryScalar: return $"{dataFrameType}<{genericType}> {Op1Name}, {genericType} {Op2Name}"; case MethodType.ComparisonScalar: - return $"{dataFrameType}<{genericType}> {Op1Name}, {genericType} {Op2Name}, {dataFrameType} ret"; + return $"{dataFrameType}<{genericType}> {Op1Name}, {genericType} {Op2Name}"; 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"; + return $"{dataFrameType}<{genericType}> {Op1Name}, {dataFrameType}<{genericType}> {Op2Name}"; case MethodType.Contraction: return $"{dataFrameType}<{genericType}> {Op1Name}, {dataFrameType}<{genericType}> {Op2Name}, int[] leftAxes, int[] rightAxes"; case MethodType.ElementwiseComputation: @@ -436,13 +430,13 @@ case MethodType.BinaryScalar: return $"{genericType} {Op2Name}"; case MethodType.ComparisonScalar: - return $"{genericType} {Op2Name}, {dataFrameType} ret"; + return $"{genericType} {Op2Name}"; case MethodType.BinaryInt: return $"int {Op2Name}"; case MethodType.Binary: return $"{dataFrameType}<{genericType}> {Op2Name}"; case MethodType.Comparison: - return $"{dataFrameType}<{genericType}> {Op2Name}, {dataFrameType} ret"; + return $"{dataFrameType}<{genericType}> {Op2Name}"; case MethodType.Contraction: throw new ArgumentException(); return $"{dataFrameType}<{genericType}> {Op1Name}, {dataFrameType}<{genericType}> {Op2Name}, int[] leftAxes, int[] rightAxes"; diff --git a/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt b/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt index a417bbf876..dc0c4fa988 100644 --- a/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt +++ b/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt @@ -78,11 +78,17 @@ namespace Microsoft.Data.Analysis <# } #> <# } #> + /// + /// Performs an element-wise equal to Null on each value in the column + /// public virtual PrimitiveDataFrameColumn ElementwiseIsNull() { throw new NotImplementedException(); } + /// + /// Performs an element-wise not equal to Null on each value in the column + /// public virtual PrimitiveDataFrameColumn ElementwiseIsNotNull() { throw new NotImplementedException(); diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs index 64b12c0607..e6c6673152 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs @@ -118,78 +118,54 @@ public PrimitiveColumnContainer RightShift(int value) return this; } - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public BooleanDataFrameColumn ElementwiseEquals(PrimitiveColumnContainer right) { - PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseEquals(this, right, ret); - return this; + return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseEquals(this, right); } - - public PrimitiveColumnContainer ElementwiseEquals(T scalar, PrimitiveColumnContainer ret) + public BooleanDataFrameColumn ElementwiseEquals(T scalar) { - PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseEquals(this, scalar, ret); - return this; + return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseEquals(this, scalar); } - - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public BooleanDataFrameColumn ElementwiseNotEquals(PrimitiveColumnContainer right) { - PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseNotEquals(this, right, ret); - return this; + return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseNotEquals(this, right); } - - public PrimitiveColumnContainer ElementwiseNotEquals(T scalar, PrimitiveColumnContainer ret) + public BooleanDataFrameColumn ElementwiseNotEquals(T scalar) { - PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseNotEquals(this, scalar, ret); - return this; + return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseNotEquals(this, scalar); } - - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer right) { - PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseGreaterThanOrEqual(this, right, ret); - return this; + return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseGreaterThanOrEqual(this, right); } - - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(T scalar, PrimitiveColumnContainer ret) + public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(T scalar) { - PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseGreaterThanOrEqual(this, scalar, ret); - return this; + return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseGreaterThanOrEqual(this, scalar); } - - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public BooleanDataFrameColumn ElementwiseLessThanOrEqual(PrimitiveColumnContainer right) { - PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseLessThanOrEqual(this, right, ret); - return this; + return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseLessThanOrEqual(this, right); } - - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(T scalar, PrimitiveColumnContainer ret) + public BooleanDataFrameColumn ElementwiseLessThanOrEqual(T scalar) { - PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseLessThanOrEqual(this, scalar, ret); - return this; + return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseLessThanOrEqual(this, scalar); } - - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public BooleanDataFrameColumn ElementwiseGreaterThan(PrimitiveColumnContainer right) { - PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseGreaterThan(this, right, ret); - return this; + return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseGreaterThan(this, right); } - - public PrimitiveColumnContainer ElementwiseGreaterThan(T scalar, PrimitiveColumnContainer ret) + public BooleanDataFrameColumn ElementwiseGreaterThan(T scalar) { - PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseGreaterThan(this, scalar, ret); - return this; + return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseGreaterThan(this, scalar); } - - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public BooleanDataFrameColumn ElementwiseLessThan(PrimitiveColumnContainer right) { - PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseLessThan(this, right, ret); - return this; + return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseLessThan(this, right); } - - public PrimitiveColumnContainer ElementwiseLessThan(T scalar, PrimitiveColumnContainer ret) + public BooleanDataFrameColumn ElementwiseLessThan(T scalar) { - PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseLessThan(this, scalar, ret); - return this; + return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseLessThan(this, scalar); } - public PrimitiveColumnContainer ReverseAdd(T scalar) { PrimitiveDataFrameColumnArithmetic.Instance.Add(scalar, this); @@ -231,4 +207,4 @@ public PrimitiveColumnContainer ReverseXor(T scalar) return this; } } -} +} \ No newline at end of file diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt index 95fc73b176..c6ce66a40b 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt +++ b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt @@ -14,20 +14,19 @@ namespace Microsoft.Data.Analysis { internal partial class PrimitiveColumnContainer - where T : struct + where T : unmanaged { <# foreach (MethodConfiguration method in methodConfiguration) { #> -<# if (method.MethodType == MethodType.Comparison || method.MethodType == MethodType.ComparisonScalar) { #> - public <#= method.GetSingleArgumentMethodSignature("PrimitiveColumnContainer", "T") #> +<# if (method.MethodType == MethodType.Comparison) { #> + public BooleanDataFrameColumn <#=method.MethodName#>(PrimitiveColumnContainer right) { -<# if (method.MethodType == MethodType.ComparisonScalar ) { #> - PrimitiveDataFrameColumnArithmetic.Instance.<#=method.MethodName#>(this, scalar, ret); -<# } else { #> - PrimitiveDataFrameColumnArithmetic.Instance.<#=method.MethodName#>(this, right, ret); -<# } #> - return this; + return PrimitiveDataFrameColumnArithmetic.Instance.<#=method.MethodName#>(this, right); + } +<# } else if (method.MethodType == MethodType.ComparisonScalar ) { #> + public BooleanDataFrameColumn <#=method.MethodName#>(T scalar) + { + return PrimitiveDataFrameColumnArithmetic.Instance.<#=method.MethodName#>(this, scalar); } - <# } else { #> public <#= method.GetSingleArgumentMethodSignature("PrimitiveColumnContainer", "T")#> { @@ -53,4 +52,4 @@ namespace Microsoft.Data.Analysis <# } #> <# } #> } -} +} \ No newline at end of file diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperators.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperators.cs index ab89c880d9..fdacb805b1 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperators.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperators.cs @@ -4,6 +4,8 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. +// Generated from PrimitiveDataFrameColumn.BinaryOperators.tt. Do not modify directly + using System; using System.Collections.Generic; using System.Text; diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperators.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperators.tt index 777dc4026d..88063aae44 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperators.tt +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperators.tt @@ -10,6 +10,8 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. +// Generated from PrimitiveDataFrameColumn.BinaryOperators.tt. Do not modify directly + using System; using System.Collections.Generic; using System.Text; diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs index 0c8a0ec2ff..d7dfd7fd67 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs @@ -39,18 +39,18 @@ internal interface IPrimitiveDataFrameColumnArithmetic void Xor(T scalar, PrimitiveColumnContainer column); void LeftShift(PrimitiveColumnContainer column, int value); void RightShift(PrimitiveColumnContainer column, int value); - void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret); - void ElementwiseEquals(PrimitiveColumnContainer column, T scalar, PrimitiveColumnContainer ret); - void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret); - void ElementwiseNotEquals(PrimitiveColumnContainer column, T scalar, PrimitiveColumnContainer ret); - void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret); - void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, T scalar, PrimitiveColumnContainer ret); - void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret); - void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, T scalar, PrimitiveColumnContainer ret); - void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret); - void ElementwiseGreaterThan(PrimitiveColumnContainer column, T scalar, PrimitiveColumnContainer ret); - void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret); - void ElementwiseLessThan(PrimitiveColumnContainer column, T scalar, PrimitiveColumnContainer ret); + void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right); + void ElementwiseEquals(PrimitiveColumnContainer column, T scalar); + void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right); + void ElementwiseNotEquals(PrimitiveColumnContainer column, T scalar); + void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right); + void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, T scalar); + void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right); + void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, T scalar); + void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right); + void ElementwiseGreaterThan(PrimitiveColumnContainer column, T scalar); + void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right); + void ElementwiseLessThan(PrimitiveColumnContainer column, T scalar); } internal static class PrimitiveDataFrameColumnArithmetic @@ -305,7 +305,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) { throw new NotSupportedException(); } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -318,7 +318,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColu } } } - public void ElementwiseEquals(PrimitiveColumnContainer column, bool scalar, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer column, bool scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -330,7 +330,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, bool scalar } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -343,7 +343,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveC } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, bool scalar, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer column, bool scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -355,35 +355,35 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, bool sca } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, bool scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, bool scalar) { throw new NotSupportedException(); } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, bool scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, bool scalar) { throw new NotSupportedException(); } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, bool scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer column, bool scalar) { throw new NotSupportedException(); } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } - public void ElementwiseLessThan(PrimitiveColumnContainer column, bool scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer column, bool scalar) { throw new NotSupportedException(); } @@ -710,7 +710,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) } } } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -723,7 +723,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColu } } } - public void ElementwiseEquals(PrimitiveColumnContainer column, byte scalar, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer column, byte scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -735,7 +735,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, byte scalar } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -748,7 +748,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveC } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, byte scalar, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer column, byte scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -760,7 +760,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, byte sca } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -773,7 +773,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, P } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, byte scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, byte scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -785,7 +785,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -798,7 +798,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Prim } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, byte scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, byte scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -810,7 +810,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, by } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -823,7 +823,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primitiv } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, byte scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer column, byte scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -835,7 +835,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, byte s } } } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -848,7 +848,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveCo } } } - public void ElementwiseLessThan(PrimitiveColumnContainer column, byte scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer column, byte scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -1183,7 +1183,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) } } } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -1196,7 +1196,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColu } } } - public void ElementwiseEquals(PrimitiveColumnContainer column, char scalar, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer column, char scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -1208,7 +1208,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, char scalar } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -1221,7 +1221,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveC } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, char scalar, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer column, char scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -1233,7 +1233,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, char sca } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -1246,7 +1246,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, P } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, char scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, char scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -1258,7 +1258,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -1271,7 +1271,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Prim } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, char scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, char scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -1283,7 +1283,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ch } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -1296,7 +1296,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primitiv } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, char scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer column, char scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -1308,7 +1308,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, char s } } } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -1321,7 +1321,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveCo } } } - public void ElementwiseLessThan(PrimitiveColumnContainer column, char scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer column, char scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -1565,7 +1565,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) { throw new NotSupportedException(); } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -1578,7 +1578,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveC } } } - public void ElementwiseEquals(PrimitiveColumnContainer column, decimal scalar, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer column, decimal scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -1590,7 +1590,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, decimal } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -1603,7 +1603,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, Primiti } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, decimal scalar, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer column, decimal scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -1615,7 +1615,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, decim } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -1628,7 +1628,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, decimal scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, decimal scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -1640,7 +1640,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer colu } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -1653,7 +1653,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, P } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, decimal scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, decimal scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -1665,7 +1665,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -1678,7 +1678,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primi } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, decimal scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer column, decimal scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -1690,7 +1690,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, dec } } } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -1703,7 +1703,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, Primitiv } } } - public void ElementwiseLessThan(PrimitiveColumnContainer column, decimal scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer column, decimal scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -1947,7 +1947,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) { throw new NotSupportedException(); } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -1960,7 +1960,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveCo } } } - public void ElementwiseEquals(PrimitiveColumnContainer column, double scalar, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer column, double scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -1972,7 +1972,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, double sc } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -1985,7 +1985,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, Primitiv } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, double scalar, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer column, double scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -1997,7 +1997,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, double } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -2010,7 +2010,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, double scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, double scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -2022,7 +2022,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer colum } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -2035,7 +2035,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Pr } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, double scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, double scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -2047,7 +2047,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -2060,7 +2060,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primit } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, double scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer column, double scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -2072,7 +2072,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, doub } } } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -2085,7 +2085,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, Primitive } } } - public void ElementwiseLessThan(PrimitiveColumnContainer column, double scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer column, double scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -2329,7 +2329,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) { throw new NotSupportedException(); } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -2342,7 +2342,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveCol } } } - public void ElementwiseEquals(PrimitiveColumnContainer column, float scalar, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer column, float scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -2354,7 +2354,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, float scal } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -2367,7 +2367,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, Primitive } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, float scalar, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer column, float scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -2379,7 +2379,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, float s } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -2392,7 +2392,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, float scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, float scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -2404,7 +2404,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -2417,7 +2417,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Pri } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, float scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, float scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -2429,7 +2429,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, f } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -2442,7 +2442,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primiti } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, float scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer column, float scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -2454,7 +2454,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, float } } } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -2467,7 +2467,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveC } } } - public void ElementwiseLessThan(PrimitiveColumnContainer column, float scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer column, float scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -2802,7 +2802,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) } } } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -2815,7 +2815,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColum } } } - public void ElementwiseEquals(PrimitiveColumnContainer column, int scalar, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer column, int scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -2827,7 +2827,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, int scalar, } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -2840,7 +2840,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveCo } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, int scalar, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer column, int scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -2852,7 +2852,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, int scala } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -2865,7 +2865,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, Pr } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, int scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, int scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -2877,7 +2877,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -2890,7 +2890,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Primi } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, int scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, int scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -2902,7 +2902,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, int } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -2915,7 +2915,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primitive } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, int scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer column, int scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -2927,7 +2927,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, int sca } } } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -2940,7 +2940,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveCol } } } - public void ElementwiseLessThan(PrimitiveColumnContainer column, int scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer column, int scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -3275,7 +3275,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) } } } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -3288,7 +3288,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColu } } } - public void ElementwiseEquals(PrimitiveColumnContainer column, long scalar, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer column, long scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -3300,7 +3300,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, long scalar } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -3313,7 +3313,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveC } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, long scalar, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer column, long scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -3325,7 +3325,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, long sca } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -3338,7 +3338,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, P } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, long scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, long scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -3350,7 +3350,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -3363,7 +3363,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Prim } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, long scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, long scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -3375,7 +3375,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, lo } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -3388,7 +3388,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primitiv } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, long scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer column, long scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -3400,7 +3400,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, long s } } } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -3413,7 +3413,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveCo } } } - public void ElementwiseLessThan(PrimitiveColumnContainer column, long scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer column, long scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -3748,7 +3748,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) } } } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -3761,7 +3761,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveCol } } } - public void ElementwiseEquals(PrimitiveColumnContainer column, sbyte scalar, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer column, sbyte scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -3773,7 +3773,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, sbyte scal } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -3786,7 +3786,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, Primitive } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, sbyte scalar, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer column, sbyte scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -3798,7 +3798,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, sbyte s } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -3811,7 +3811,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, sbyte scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, sbyte scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -3823,7 +3823,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -3836,7 +3836,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Pri } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, sbyte scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, sbyte scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -3848,7 +3848,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, s } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -3861,7 +3861,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primiti } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, sbyte scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer column, sbyte scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -3873,7 +3873,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, sbyte } } } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -3886,7 +3886,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveC } } } - public void ElementwiseLessThan(PrimitiveColumnContainer column, sbyte scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer column, sbyte scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -4221,7 +4221,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) } } } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -4234,7 +4234,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveCol } } } - public void ElementwiseEquals(PrimitiveColumnContainer column, short scalar, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer column, short scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -4246,7 +4246,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, short scal } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -4259,7 +4259,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, Primitive } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, short scalar, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer column, short scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -4271,7 +4271,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, short s } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -4284,7 +4284,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, short scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, short scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -4296,7 +4296,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -4309,7 +4309,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Pri } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, short scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, short scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -4321,7 +4321,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, s } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -4334,7 +4334,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primiti } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, short scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer column, short scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -4346,7 +4346,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, short } } } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -4359,7 +4359,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveC } } } - public void ElementwiseLessThan(PrimitiveColumnContainer column, short scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer column, short scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -4694,7 +4694,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) } } } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -4707,7 +4707,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColu } } } - public void ElementwiseEquals(PrimitiveColumnContainer column, uint scalar, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer column, uint scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -4719,7 +4719,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, uint scalar } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -4732,7 +4732,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveC } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, uint scalar, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer column, uint scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -4744,7 +4744,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, uint sca } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -4757,7 +4757,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, P } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, uint scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, uint scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -4769,7 +4769,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -4782,7 +4782,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Prim } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, uint scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, uint scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -4794,7 +4794,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ui } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -4807,7 +4807,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primitiv } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, uint scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer column, uint scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -4819,7 +4819,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, uint s } } } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -4832,7 +4832,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveCo } } } - public void ElementwiseLessThan(PrimitiveColumnContainer column, uint scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer column, uint scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -5167,7 +5167,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) } } } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -5180,7 +5180,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveCol } } } - public void ElementwiseEquals(PrimitiveColumnContainer column, ulong scalar, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer column, ulong scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -5192,7 +5192,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, ulong scal } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -5205,7 +5205,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, Primitive } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, ulong scalar, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer column, ulong scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -5217,7 +5217,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, ulong s } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -5230,7 +5230,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, ulong scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, ulong scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -5242,7 +5242,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -5255,7 +5255,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Pri } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ulong scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ulong scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -5267,7 +5267,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, u } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -5280,7 +5280,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primiti } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, ulong scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer column, ulong scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -5292,7 +5292,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, ulong } } } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -5305,7 +5305,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveC } } } - public void ElementwiseLessThan(PrimitiveColumnContainer column, ulong scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer column, ulong scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -5640,7 +5640,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) } } } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -5653,7 +5653,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveCo } } } - public void ElementwiseEquals(PrimitiveColumnContainer column, ushort scalar, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer column, ushort scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -5665,7 +5665,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, ushort sc } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -5678,7 +5678,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, Primitiv } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, ushort scalar, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer column, ushort scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -5690,7 +5690,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, ushort } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -5703,7 +5703,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, ushort scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, ushort scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -5715,7 +5715,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer colum } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -5728,7 +5728,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Pr } } } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ushort scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ushort scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -5740,7 +5740,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -5753,7 +5753,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primit } } } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, ushort scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer column, ushort scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -5765,7 +5765,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, usho } } } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -5778,7 +5778,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, Primitive } } } - public void ElementwiseLessThan(PrimitiveColumnContainer column, ushort scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer column, ushort scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -5897,7 +5897,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) { throw new NotSupportedException(); } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -5910,7 +5910,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, Primitive } } } - public void ElementwiseEquals(PrimitiveColumnContainer column, DateTime scalar, PrimitiveColumnContainer ret) + public void ElementwiseEquals(PrimitiveColumnContainer column, DateTime scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -5922,7 +5922,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, DateTim } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { long index = 0; for (int b = 0; b < left.Buffers.Count; b++) @@ -5935,7 +5935,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, Primit } } } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, DateTime scalar, PrimitiveColumnContainer ret) + public void ElementwiseNotEquals(PrimitiveColumnContainer column, DateTime scalar) { long index = 0; for (int b = 0; b < column.Buffers.Count; b++) @@ -5947,35 +5947,35 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, Date } } } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, DateTime scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, DateTime scalar) { throw new NotSupportedException(); } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, DateTime scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, DateTime scalar) { throw new NotSupportedException(); } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, DateTime scalar, PrimitiveColumnContainer ret) + public void ElementwiseGreaterThan(PrimitiveColumnContainer column, DateTime scalar) { throw new NotSupportedException(); } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } - public void ElementwiseLessThan(PrimitiveColumnContainer column, DateTime scalar, PrimitiveColumnContainer ret) + public void ElementwiseLessThan(PrimitiveColumnContainer column, DateTime scalar) { throw new NotSupportedException(); } diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt index a1543efd2d..790eb2bfca 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt @@ -21,7 +21,7 @@ namespace Microsoft.Data.Analysis where T : unmanaged { <# foreach (MethodConfiguration method in methodConfiguration) { #> - <#= method.GetMethodSignature("PrimitiveColumnContainer", "T")#>; + void <#=method.MethodName#>(<#=method.GetMethodArguments("PrimitiveColumnContainer", "T")#>); <# if (method.MethodType == MethodType.BinaryScalar) { #> <#= method.GetInvertedMethodSignatureForBinaryScalarsOps("PrimitiveColumnContainer", "T")#>; <# } #> @@ -53,7 +53,7 @@ namespace Microsoft.Data.Analysis internal class <#=type.ClassPrefix#>Arithmetic : IPrimitiveDataFrameColumnArithmetic<<#=type.TypeName#>> { <# foreach (MethodConfiguration method in methodConfiguration) { #> - public <#= method.GetMethodSignature("PrimitiveColumnContainer", type.TypeName) #> + public void <#=method.MethodName#>(<#=method.GetMethodArguments("PrimitiveColumnContainer", type.TypeName)#>) { <# if ((method.IsNumeric && !type.SupportsNumeric) || (method.IsBitwise && !type.SupportsBitwise) || (type.UnsupportedMethods.Contains(method.MethodName))) { #> throw new NotSupportedException(); From bf29980fdd0ec9fdd06ccb5a35df7c81629729bf Mon Sep 17 00:00:00 2001 From: Aleksei Smirnov Date: Thu, 13 Jul 2023 17:25:00 +0300 Subject: [PATCH 13/18] Change DataFrameColumn Arithmetics --- ...imitiveColumnContainer.BinaryOperations.cs | 24 +- ...imitiveColumnContainer.BinaryOperations.tt | 4 +- ...BinaryOperationImplementations.Exploded.cs | 850 ++++++------ ...BinaryOperationImplementations.Exploded.tt | 11 +- .../PrimitiveDataFrameColumnArithmetic.cs | 1197 ++++++++++++++--- .../PrimitiveDataFrameColumnArithmetic.tt | 17 +- 6 files changed, 1433 insertions(+), 670 deletions(-) diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs index e6c6673152..a17c888f36 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs @@ -118,51 +118,51 @@ public PrimitiveColumnContainer RightShift(int value) return this; } - public BooleanDataFrameColumn ElementwiseEquals(PrimitiveColumnContainer right) + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer right) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseEquals(this, right); } - public BooleanDataFrameColumn ElementwiseEquals(T scalar) + public PrimitiveColumnContainer ElementwiseEquals(T scalar) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseEquals(this, scalar); } - public BooleanDataFrameColumn ElementwiseNotEquals(PrimitiveColumnContainer right) + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer right) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseNotEquals(this, right); } - public BooleanDataFrameColumn ElementwiseNotEquals(T scalar) + public PrimitiveColumnContainer ElementwiseNotEquals(T scalar) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseNotEquals(this, scalar); } - public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer right) + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer right) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseGreaterThanOrEqual(this, right); } - public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(T scalar) + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(T scalar) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseGreaterThanOrEqual(this, scalar); } - public BooleanDataFrameColumn ElementwiseLessThanOrEqual(PrimitiveColumnContainer right) + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer right) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseLessThanOrEqual(this, right); } - public BooleanDataFrameColumn ElementwiseLessThanOrEqual(T scalar) + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(T scalar) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseLessThanOrEqual(this, scalar); } - public BooleanDataFrameColumn ElementwiseGreaterThan(PrimitiveColumnContainer right) + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer right) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseGreaterThan(this, right); } - public BooleanDataFrameColumn ElementwiseGreaterThan(T scalar) + public PrimitiveColumnContainer ElementwiseGreaterThan(T scalar) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseGreaterThan(this, scalar); } - public BooleanDataFrameColumn ElementwiseLessThan(PrimitiveColumnContainer right) + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer right) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseLessThan(this, right); } - public BooleanDataFrameColumn ElementwiseLessThan(T scalar) + public PrimitiveColumnContainer ElementwiseLessThan(T scalar) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseLessThan(this, scalar); } diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt index c6ce66a40b..9bdd5c9c85 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt +++ b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt @@ -18,12 +18,12 @@ namespace Microsoft.Data.Analysis { <# foreach (MethodConfiguration method in methodConfiguration) { #> <# if (method.MethodType == MethodType.Comparison) { #> - public BooleanDataFrameColumn <#=method.MethodName#>(PrimitiveColumnContainer right) + public PrimitiveColumnContainer <#=method.MethodName#>(PrimitiveColumnContainer right) { return PrimitiveDataFrameColumnArithmetic.Instance.<#=method.MethodName#>(this, right); } <# } else if (method.MethodType == MethodType.ComparisonScalar ) { #> - public BooleanDataFrameColumn <#=method.MethodName#>(T scalar) + public PrimitiveColumnContainer <#=method.MethodName#>(T scalar) { return PrimitiveDataFrameColumnArithmetic.Instance.<#=method.MethodName#>(this, scalar); } diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs index af3ac7e5ee..95e443545e 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs @@ -102,6 +102,7 @@ internal UInt64DataFrameColumn AddImplementation(UInt64DataFrameColumn column, b return newColumn; } } + public partial class DecimalDataFrameColumn { internal DecimalDataFrameColumn AddImplementation(decimal value, bool inPlace = false) @@ -111,6 +112,7 @@ internal DecimalDataFrameColumn AddImplementation(decimal value, bool inPlace = return newColumn; } } + public partial class DoubleDataFrameColumn { internal DoubleDataFrameColumn AddImplementation(double value, bool inPlace = false) @@ -120,6 +122,7 @@ internal DoubleDataFrameColumn AddImplementation(double value, bool inPlace = fa return newColumn; } } + public partial class SingleDataFrameColumn { internal SingleDataFrameColumn AddImplementation(float value, bool inPlace = false) @@ -129,6 +132,7 @@ internal SingleDataFrameColumn AddImplementation(float value, bool inPlace = fal return newColumn; } } + public partial class Int32DataFrameColumn { internal Int32DataFrameColumn AddImplementation(int value, bool inPlace = false) @@ -138,6 +142,7 @@ internal Int32DataFrameColumn AddImplementation(int value, bool inPlace = false) return newColumn; } } + public partial class Int64DataFrameColumn { internal Int64DataFrameColumn AddImplementation(long value, bool inPlace = false) @@ -147,6 +152,7 @@ internal Int64DataFrameColumn AddImplementation(long value, bool inPlace = false return newColumn; } } + public partial class UInt32DataFrameColumn { internal UInt32DataFrameColumn AddImplementation(uint value, bool inPlace = false) @@ -156,6 +162,7 @@ internal UInt32DataFrameColumn AddImplementation(uint value, bool inPlace = fals return newColumn; } } + public partial class UInt64DataFrameColumn { internal UInt64DataFrameColumn AddImplementation(ulong value, bool inPlace = false) @@ -165,6 +172,7 @@ internal UInt64DataFrameColumn AddImplementation(ulong value, bool inPlace = fal return newColumn; } } + public partial class DecimalDataFrameColumn { internal DecimalDataFrameColumn ReverseAddImplementation(decimal value, bool inPlace = false) @@ -174,6 +182,7 @@ internal DecimalDataFrameColumn ReverseAddImplementation(decimal value, bool inP return newColumn; } } + public partial class DoubleDataFrameColumn { internal DoubleDataFrameColumn ReverseAddImplementation(double value, bool inPlace = false) @@ -183,6 +192,7 @@ internal DoubleDataFrameColumn ReverseAddImplementation(double value, bool inPla return newColumn; } } + public partial class SingleDataFrameColumn { internal SingleDataFrameColumn ReverseAddImplementation(float value, bool inPlace = false) @@ -192,6 +202,7 @@ internal SingleDataFrameColumn ReverseAddImplementation(float value, bool inPlac return newColumn; } } + public partial class Int32DataFrameColumn { internal Int32DataFrameColumn ReverseAddImplementation(int value, bool inPlace = false) @@ -201,6 +212,7 @@ internal Int32DataFrameColumn ReverseAddImplementation(int value, bool inPlace = return newColumn; } } + public partial class Int64DataFrameColumn { internal Int64DataFrameColumn ReverseAddImplementation(long value, bool inPlace = false) @@ -210,6 +222,7 @@ internal Int64DataFrameColumn ReverseAddImplementation(long value, bool inPlace return newColumn; } } + public partial class UInt32DataFrameColumn { internal UInt32DataFrameColumn ReverseAddImplementation(uint value, bool inPlace = false) @@ -219,6 +232,7 @@ internal UInt32DataFrameColumn ReverseAddImplementation(uint value, bool inPlace return newColumn; } } + public partial class UInt64DataFrameColumn { internal UInt64DataFrameColumn ReverseAddImplementation(ulong value, bool inPlace = false) @@ -319,6 +333,7 @@ internal UInt64DataFrameColumn SubtractImplementation(UInt64DataFrameColumn colu return newColumn; } } + public partial class DecimalDataFrameColumn { internal DecimalDataFrameColumn SubtractImplementation(decimal value, bool inPlace = false) @@ -328,6 +343,7 @@ internal DecimalDataFrameColumn SubtractImplementation(decimal value, bool inPla return newColumn; } } + public partial class DoubleDataFrameColumn { internal DoubleDataFrameColumn SubtractImplementation(double value, bool inPlace = false) @@ -337,6 +353,7 @@ internal DoubleDataFrameColumn SubtractImplementation(double value, bool inPlace return newColumn; } } + public partial class SingleDataFrameColumn { internal SingleDataFrameColumn SubtractImplementation(float value, bool inPlace = false) @@ -346,6 +363,7 @@ internal SingleDataFrameColumn SubtractImplementation(float value, bool inPlace return newColumn; } } + public partial class Int32DataFrameColumn { internal Int32DataFrameColumn SubtractImplementation(int value, bool inPlace = false) @@ -355,6 +373,7 @@ internal Int32DataFrameColumn SubtractImplementation(int value, bool inPlace = f return newColumn; } } + public partial class Int64DataFrameColumn { internal Int64DataFrameColumn SubtractImplementation(long value, bool inPlace = false) @@ -364,6 +383,7 @@ internal Int64DataFrameColumn SubtractImplementation(long value, bool inPlace = return newColumn; } } + public partial class UInt32DataFrameColumn { internal UInt32DataFrameColumn SubtractImplementation(uint value, bool inPlace = false) @@ -373,6 +393,7 @@ internal UInt32DataFrameColumn SubtractImplementation(uint value, bool inPlace = return newColumn; } } + public partial class UInt64DataFrameColumn { internal UInt64DataFrameColumn SubtractImplementation(ulong value, bool inPlace = false) @@ -382,6 +403,7 @@ internal UInt64DataFrameColumn SubtractImplementation(ulong value, bool inPlace return newColumn; } } + public partial class DecimalDataFrameColumn { internal DecimalDataFrameColumn ReverseSubtractImplementation(decimal value, bool inPlace = false) @@ -391,6 +413,7 @@ internal DecimalDataFrameColumn ReverseSubtractImplementation(decimal value, boo return newColumn; } } + public partial class DoubleDataFrameColumn { internal DoubleDataFrameColumn ReverseSubtractImplementation(double value, bool inPlace = false) @@ -400,6 +423,7 @@ internal DoubleDataFrameColumn ReverseSubtractImplementation(double value, bool return newColumn; } } + public partial class SingleDataFrameColumn { internal SingleDataFrameColumn ReverseSubtractImplementation(float value, bool inPlace = false) @@ -409,6 +433,7 @@ internal SingleDataFrameColumn ReverseSubtractImplementation(float value, bool i return newColumn; } } + public partial class Int32DataFrameColumn { internal Int32DataFrameColumn ReverseSubtractImplementation(int value, bool inPlace = false) @@ -418,6 +443,7 @@ internal Int32DataFrameColumn ReverseSubtractImplementation(int value, bool inPl return newColumn; } } + public partial class Int64DataFrameColumn { internal Int64DataFrameColumn ReverseSubtractImplementation(long value, bool inPlace = false) @@ -427,6 +453,7 @@ internal Int64DataFrameColumn ReverseSubtractImplementation(long value, bool inP return newColumn; } } + public partial class UInt32DataFrameColumn { internal UInt32DataFrameColumn ReverseSubtractImplementation(uint value, bool inPlace = false) @@ -436,6 +463,7 @@ internal UInt32DataFrameColumn ReverseSubtractImplementation(uint value, bool in return newColumn; } } + public partial class UInt64DataFrameColumn { internal UInt64DataFrameColumn ReverseSubtractImplementation(ulong value, bool inPlace = false) @@ -536,6 +564,7 @@ internal UInt64DataFrameColumn MultiplyImplementation(UInt64DataFrameColumn colu return newColumn; } } + public partial class DecimalDataFrameColumn { internal DecimalDataFrameColumn MultiplyImplementation(decimal value, bool inPlace = false) @@ -545,6 +574,7 @@ internal DecimalDataFrameColumn MultiplyImplementation(decimal value, bool inPla return newColumn; } } + public partial class DoubleDataFrameColumn { internal DoubleDataFrameColumn MultiplyImplementation(double value, bool inPlace = false) @@ -554,6 +584,7 @@ internal DoubleDataFrameColumn MultiplyImplementation(double value, bool inPlace return newColumn; } } + public partial class SingleDataFrameColumn { internal SingleDataFrameColumn MultiplyImplementation(float value, bool inPlace = false) @@ -563,6 +594,7 @@ internal SingleDataFrameColumn MultiplyImplementation(float value, bool inPlace return newColumn; } } + public partial class Int32DataFrameColumn { internal Int32DataFrameColumn MultiplyImplementation(int value, bool inPlace = false) @@ -572,6 +604,7 @@ internal Int32DataFrameColumn MultiplyImplementation(int value, bool inPlace = f return newColumn; } } + public partial class Int64DataFrameColumn { internal Int64DataFrameColumn MultiplyImplementation(long value, bool inPlace = false) @@ -581,6 +614,7 @@ internal Int64DataFrameColumn MultiplyImplementation(long value, bool inPlace = return newColumn; } } + public partial class UInt32DataFrameColumn { internal UInt32DataFrameColumn MultiplyImplementation(uint value, bool inPlace = false) @@ -590,6 +624,7 @@ internal UInt32DataFrameColumn MultiplyImplementation(uint value, bool inPlace = return newColumn; } } + public partial class UInt64DataFrameColumn { internal UInt64DataFrameColumn MultiplyImplementation(ulong value, bool inPlace = false) @@ -599,6 +634,7 @@ internal UInt64DataFrameColumn MultiplyImplementation(ulong value, bool inPlace return newColumn; } } + public partial class DecimalDataFrameColumn { internal DecimalDataFrameColumn ReverseMultiplyImplementation(decimal value, bool inPlace = false) @@ -608,6 +644,7 @@ internal DecimalDataFrameColumn ReverseMultiplyImplementation(decimal value, boo return newColumn; } } + public partial class DoubleDataFrameColumn { internal DoubleDataFrameColumn ReverseMultiplyImplementation(double value, bool inPlace = false) @@ -617,6 +654,7 @@ internal DoubleDataFrameColumn ReverseMultiplyImplementation(double value, bool return newColumn; } } + public partial class SingleDataFrameColumn { internal SingleDataFrameColumn ReverseMultiplyImplementation(float value, bool inPlace = false) @@ -626,6 +664,7 @@ internal SingleDataFrameColumn ReverseMultiplyImplementation(float value, bool i return newColumn; } } + public partial class Int32DataFrameColumn { internal Int32DataFrameColumn ReverseMultiplyImplementation(int value, bool inPlace = false) @@ -635,6 +674,7 @@ internal Int32DataFrameColumn ReverseMultiplyImplementation(int value, bool inPl return newColumn; } } + public partial class Int64DataFrameColumn { internal Int64DataFrameColumn ReverseMultiplyImplementation(long value, bool inPlace = false) @@ -644,6 +684,7 @@ internal Int64DataFrameColumn ReverseMultiplyImplementation(long value, bool inP return newColumn; } } + public partial class UInt32DataFrameColumn { internal UInt32DataFrameColumn ReverseMultiplyImplementation(uint value, bool inPlace = false) @@ -653,6 +694,7 @@ internal UInt32DataFrameColumn ReverseMultiplyImplementation(uint value, bool in return newColumn; } } + public partial class UInt64DataFrameColumn { internal UInt64DataFrameColumn ReverseMultiplyImplementation(ulong value, bool inPlace = false) @@ -753,6 +795,7 @@ internal UInt64DataFrameColumn DivideImplementation(UInt64DataFrameColumn column return newColumn; } } + public partial class DecimalDataFrameColumn { internal DecimalDataFrameColumn DivideImplementation(decimal value, bool inPlace = false) @@ -762,6 +805,7 @@ internal DecimalDataFrameColumn DivideImplementation(decimal value, bool inPlace return newColumn; } } + public partial class DoubleDataFrameColumn { internal DoubleDataFrameColumn DivideImplementation(double value, bool inPlace = false) @@ -771,6 +815,7 @@ internal DoubleDataFrameColumn DivideImplementation(double value, bool inPlace = return newColumn; } } + public partial class SingleDataFrameColumn { internal SingleDataFrameColumn DivideImplementation(float value, bool inPlace = false) @@ -780,6 +825,7 @@ internal SingleDataFrameColumn DivideImplementation(float value, bool inPlace = return newColumn; } } + public partial class Int32DataFrameColumn { internal Int32DataFrameColumn DivideImplementation(int value, bool inPlace = false) @@ -789,6 +835,7 @@ internal Int32DataFrameColumn DivideImplementation(int value, bool inPlace = fal return newColumn; } } + public partial class Int64DataFrameColumn { internal Int64DataFrameColumn DivideImplementation(long value, bool inPlace = false) @@ -798,6 +845,7 @@ internal Int64DataFrameColumn DivideImplementation(long value, bool inPlace = fa return newColumn; } } + public partial class UInt32DataFrameColumn { internal UInt32DataFrameColumn DivideImplementation(uint value, bool inPlace = false) @@ -807,6 +855,7 @@ internal UInt32DataFrameColumn DivideImplementation(uint value, bool inPlace = f return newColumn; } } + public partial class UInt64DataFrameColumn { internal UInt64DataFrameColumn DivideImplementation(ulong value, bool inPlace = false) @@ -816,6 +865,7 @@ internal UInt64DataFrameColumn DivideImplementation(ulong value, bool inPlace = return newColumn; } } + public partial class DecimalDataFrameColumn { internal DecimalDataFrameColumn ReverseDivideImplementation(decimal value, bool inPlace = false) @@ -825,6 +875,7 @@ internal DecimalDataFrameColumn ReverseDivideImplementation(decimal value, bool return newColumn; } } + public partial class DoubleDataFrameColumn { internal DoubleDataFrameColumn ReverseDivideImplementation(double value, bool inPlace = false) @@ -834,6 +885,7 @@ internal DoubleDataFrameColumn ReverseDivideImplementation(double value, bool in return newColumn; } } + public partial class SingleDataFrameColumn { internal SingleDataFrameColumn ReverseDivideImplementation(float value, bool inPlace = false) @@ -843,6 +895,7 @@ internal SingleDataFrameColumn ReverseDivideImplementation(float value, bool inP return newColumn; } } + public partial class Int32DataFrameColumn { internal Int32DataFrameColumn ReverseDivideImplementation(int value, bool inPlace = false) @@ -852,6 +905,7 @@ internal Int32DataFrameColumn ReverseDivideImplementation(int value, bool inPlac return newColumn; } } + public partial class Int64DataFrameColumn { internal Int64DataFrameColumn ReverseDivideImplementation(long value, bool inPlace = false) @@ -861,6 +915,7 @@ internal Int64DataFrameColumn ReverseDivideImplementation(long value, bool inPla return newColumn; } } + public partial class UInt32DataFrameColumn { internal UInt32DataFrameColumn ReverseDivideImplementation(uint value, bool inPlace = false) @@ -870,6 +925,7 @@ internal UInt32DataFrameColumn ReverseDivideImplementation(uint value, bool inPl return newColumn; } } + public partial class UInt64DataFrameColumn { internal UInt64DataFrameColumn ReverseDivideImplementation(ulong value, bool inPlace = false) @@ -970,6 +1026,7 @@ internal UInt64DataFrameColumn ModuloImplementation(UInt64DataFrameColumn column return newColumn; } } + public partial class DecimalDataFrameColumn { internal DecimalDataFrameColumn ModuloImplementation(decimal value, bool inPlace = false) @@ -979,6 +1036,7 @@ internal DecimalDataFrameColumn ModuloImplementation(decimal value, bool inPlace return newColumn; } } + public partial class DoubleDataFrameColumn { internal DoubleDataFrameColumn ModuloImplementation(double value, bool inPlace = false) @@ -988,6 +1046,7 @@ internal DoubleDataFrameColumn ModuloImplementation(double value, bool inPlace = return newColumn; } } + public partial class SingleDataFrameColumn { internal SingleDataFrameColumn ModuloImplementation(float value, bool inPlace = false) @@ -997,6 +1056,7 @@ internal SingleDataFrameColumn ModuloImplementation(float value, bool inPlace = return newColumn; } } + public partial class Int32DataFrameColumn { internal Int32DataFrameColumn ModuloImplementation(int value, bool inPlace = false) @@ -1006,6 +1066,7 @@ internal Int32DataFrameColumn ModuloImplementation(int value, bool inPlace = fal return newColumn; } } + public partial class Int64DataFrameColumn { internal Int64DataFrameColumn ModuloImplementation(long value, bool inPlace = false) @@ -1015,6 +1076,7 @@ internal Int64DataFrameColumn ModuloImplementation(long value, bool inPlace = fa return newColumn; } } + public partial class UInt32DataFrameColumn { internal UInt32DataFrameColumn ModuloImplementation(uint value, bool inPlace = false) @@ -1024,6 +1086,7 @@ internal UInt32DataFrameColumn ModuloImplementation(uint value, bool inPlace = f return newColumn; } } + public partial class UInt64DataFrameColumn { internal UInt64DataFrameColumn ModuloImplementation(ulong value, bool inPlace = false) @@ -1033,6 +1096,7 @@ internal UInt64DataFrameColumn ModuloImplementation(ulong value, bool inPlace = return newColumn; } } + public partial class DecimalDataFrameColumn { internal DecimalDataFrameColumn ReverseModuloImplementation(decimal value, bool inPlace = false) @@ -1042,6 +1106,7 @@ internal DecimalDataFrameColumn ReverseModuloImplementation(decimal value, bool return newColumn; } } + public partial class DoubleDataFrameColumn { internal DoubleDataFrameColumn ReverseModuloImplementation(double value, bool inPlace = false) @@ -1051,6 +1116,7 @@ internal DoubleDataFrameColumn ReverseModuloImplementation(double value, bool in return newColumn; } } + public partial class SingleDataFrameColumn { internal SingleDataFrameColumn ReverseModuloImplementation(float value, bool inPlace = false) @@ -1060,6 +1126,7 @@ internal SingleDataFrameColumn ReverseModuloImplementation(float value, bool inP return newColumn; } } + public partial class Int32DataFrameColumn { internal Int32DataFrameColumn ReverseModuloImplementation(int value, bool inPlace = false) @@ -1069,6 +1136,7 @@ internal Int32DataFrameColumn ReverseModuloImplementation(int value, bool inPlac return newColumn; } } + public partial class Int64DataFrameColumn { internal Int64DataFrameColumn ReverseModuloImplementation(long value, bool inPlace = false) @@ -1078,6 +1146,7 @@ internal Int64DataFrameColumn ReverseModuloImplementation(long value, bool inPla return newColumn; } } + public partial class UInt32DataFrameColumn { internal UInt32DataFrameColumn ReverseModuloImplementation(uint value, bool inPlace = false) @@ -1087,6 +1156,7 @@ internal UInt32DataFrameColumn ReverseModuloImplementation(uint value, bool inPl return newColumn; } } + public partial class UInt64DataFrameColumn { internal UInt64DataFrameColumn ReverseModuloImplementation(ulong value, bool inPlace = false) @@ -1096,1408 +1166,1252 @@ internal UInt64DataFrameColumn ReverseModuloImplementation(ulong value, bool inP return newColumn; } } + public partial class BooleanDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(BooleanDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer)); } } + public partial class ByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(ByteDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer)); } } + public partial class DecimalDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(DecimalDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer)); } } + public partial class DoubleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(DoubleDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer)); } } + public partial class SingleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(SingleDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer)); } } + public partial class Int32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(Int32DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer)); } } + public partial class Int64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(Int64DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer)); } } + public partial class SByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(SByteDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer)); } } + public partial class Int16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(Int16DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer)); } } + public partial class UInt32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(UInt32DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer)); } } + public partial class UInt64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(UInt64DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer)); } } + public partial class UInt16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(UInt16DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer)); } } + public partial class DateTimeDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(DateTimeDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer)); } } + public partial class BooleanDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(bool value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); } } + public partial class ByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(byte value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); } } + public partial class DecimalDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(decimal value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); } } + public partial class DoubleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(double value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); } } + public partial class SingleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(float value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); } } + public partial class Int32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(int value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); } } + public partial class Int64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(long value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); } } + public partial class SByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(sbyte value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); } } + public partial class Int16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(short value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); } } + public partial class UInt32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(uint value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); } } + public partial class UInt64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(ulong value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); } } + public partial class UInt16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(ushort value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); } } + public partial class DateTimeDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(DateTime value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); } } + public partial class BooleanDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(BooleanDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer)); } } + public partial class ByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(ByteDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer)); } } + public partial class DecimalDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(DecimalDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer)); } } + public partial class DoubleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(DoubleDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer)); } } + public partial class SingleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(SingleDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer)); } } + public partial class Int32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(Int32DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer)); } } + public partial class Int64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(Int64DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer)); } } + public partial class SByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(SByteDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer)); } } + public partial class Int16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(Int16DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer)); } } + public partial class UInt32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(UInt32DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer)); } } + public partial class UInt64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(UInt64DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer)); } } + public partial class UInt16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(UInt16DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer)); } } + public partial class DateTimeDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(DateTimeDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer)); } } + public partial class BooleanDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(bool value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); } } + public partial class ByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(byte value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); } } + public partial class DecimalDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(decimal value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); } } + public partial class DoubleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(double value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); } } + public partial class SingleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(float value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); } } + public partial class Int32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(int value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); } } + public partial class Int64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(long value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); } } + public partial class SByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(sbyte value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); } } + public partial class Int16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(short value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); } } + public partial class UInt32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(uint value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); } } + public partial class UInt64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(ulong value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); } } + public partial class UInt16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(ushort value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); } } + public partial class DateTimeDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(DateTime value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); } } + public partial class BooleanDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(BooleanDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer)); } } + public partial class ByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(ByteDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer)); } } + public partial class DecimalDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(DecimalDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer)); } } + public partial class DoubleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(DoubleDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer)); } } + public partial class SingleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(SingleDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer)); } } + public partial class Int32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(Int32DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer)); } } + public partial class Int64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(Int64DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer)); } } + public partial class SByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(SByteDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer)); } } + public partial class Int16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(Int16DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer)); } } + public partial class UInt32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(UInt32DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer)); } } + public partial class UInt64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(UInt64DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer)); } } + public partial class UInt16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(UInt16DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer)); } } + public partial class DateTimeDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(DateTimeDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer)); } } + public partial class BooleanDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(bool value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } + public partial class ByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(byte value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } + public partial class DecimalDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(decimal value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } + public partial class DoubleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(double value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } + public partial class SingleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(float value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } + public partial class Int32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(int value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } + public partial class Int64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(long value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } + public partial class SByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(sbyte value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } + public partial class Int16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(short value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } + public partial class UInt32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(uint value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } + public partial class UInt64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(ulong value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } + public partial class UInt16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(ushort value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } + public partial class DateTimeDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(DateTime value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } + public partial class BooleanDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(BooleanDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer)); } } + public partial class ByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(ByteDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer)); } } + public partial class DecimalDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(DecimalDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer)); } } + public partial class DoubleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(DoubleDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer)); } } + public partial class SingleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(SingleDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer)); } } + public partial class Int32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(Int32DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer)); } } + public partial class Int64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(Int64DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer)); } } + public partial class SByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(SByteDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer)); } } + public partial class Int16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(Int16DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer)); } } + public partial class UInt32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(UInt32DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer)); } } + public partial class UInt64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(UInt64DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer)); } } + public partial class UInt16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(UInt16DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer)); } } + public partial class DateTimeDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(DateTimeDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer)); } } + public partial class BooleanDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(bool value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } + public partial class ByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(byte value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } + public partial class DecimalDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(decimal value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } + public partial class DoubleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(double value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } + public partial class SingleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(float value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } + public partial class Int32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(int value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } + public partial class Int64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(long value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } + public partial class SByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(sbyte value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } + public partial class Int16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(short value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } + public partial class UInt32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(uint value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } + public partial class UInt64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(ulong value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } + public partial class UInt16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(ushort value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } + public partial class DateTimeDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(DateTime value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } + public partial class BooleanDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(BooleanDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer)); } } + public partial class ByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(ByteDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer)); } } + public partial class DecimalDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(DecimalDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer)); } } + public partial class DoubleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(DoubleDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer)); } } + public partial class SingleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(SingleDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer)); } } + public partial class Int32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(Int32DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer)); } } + public partial class Int64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(Int64DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer)); } } + public partial class SByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(SByteDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer)); } } + public partial class Int16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(Int16DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer)); } } + public partial class UInt32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(UInt32DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer)); } } + public partial class UInt64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(UInt64DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer)); } } + public partial class UInt16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(UInt16DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer)); } } + public partial class DateTimeDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(DateTimeDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer)); } } + public partial class BooleanDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(bool value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); } } + public partial class ByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(byte value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); } } + public partial class DecimalDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(decimal value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); } } + public partial class DoubleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(double value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); } } + public partial class SingleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(float value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); } } + public partial class Int32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(int value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); } } + public partial class Int64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(long value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); } } + public partial class SByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(sbyte value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); } } + public partial class Int16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(short value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); } } + public partial class UInt32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(uint value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); } } + public partial class UInt64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(ulong value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); } } + public partial class UInt16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(ushort value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); } } + public partial class DateTimeDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(DateTime value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); } } + public partial class BooleanDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(BooleanDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer)); } } + public partial class ByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(ByteDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer)); } } + public partial class DecimalDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(DecimalDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer)); } } + public partial class DoubleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(DoubleDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer)); } } + public partial class SingleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(SingleDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer)); } } + public partial class Int32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(Int32DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer)); } } + public partial class Int64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(Int64DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer)); } } + public partial class SByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(SByteDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer)); } } + public partial class Int16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(Int16DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer)); } } + public partial class UInt32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(UInt32DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer)); } } + public partial class UInt64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(UInt64DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer)); } } + public partial class UInt16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(UInt16DataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer)); } } + public partial class DateTimeDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(DateTimeDataFrameColumn column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer)); } } + public partial class BooleanDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(bool value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); } } + public partial class ByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(byte value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); } } + public partial class DecimalDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(decimal value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); } } + public partial class DoubleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(double value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); } } + public partial class SingleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(float value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); } } + public partial class Int32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(int value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); } } + public partial class Int64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(long value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); } } + public partial class SByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(sbyte value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); } } + public partial class Int16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(short value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); } } + public partial class UInt32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(uint value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); } } + public partial class UInt64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(ulong value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); } } + public partial class UInt16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(ushort value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); } } + public partial class DateTimeDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(DateTime value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); } } } diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt index d71534742a..b71ba41c3b 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt @@ -112,6 +112,7 @@ void GenerateAllBinaryScalarCombinationsForMethod(string inputMethodName) string methodName = inputMethodName; methodName += "Implementation"; #> + public partial class <#=fullColumnType#> { <# @@ -161,13 +162,12 @@ void GenerateAllComparisonCombinationsForMethod(string inputMethodName) methodName += "Implementation"; #> + public partial class <#=fullColumnType#> { internal <#=fullReturnType#> <#=methodName#>(<#=fullOtherColumnType#> column) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.<#=inputMethodName#>(column.ColumnContainer, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, ColumnContainer.<#=inputMethodName#>(column.ColumnContainer)); } } <# @@ -196,13 +196,12 @@ void GenerateAllComparisonScalarCombinationsForMethod(string inputMethodName) methodName += "Implementation"; #> + public partial class <#=fullColumnType#> { internal <#=fullReturnType#> <#=methodName#>(<#=otherColumnType#> value) { - BooleanDataFrameColumn newColumn = CloneAsBooleanColumn(); - ColumnContainer.<#=inputMethodName#>(value, newColumn.ColumnContainer); - return newColumn; + return new BooleanDataFrameColumn (Name, ColumnContainer.<#=inputMethodName#>(value)); } } <# diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs index d7dfd7fd67..8c976fbcaf 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs @@ -39,18 +39,18 @@ internal interface IPrimitiveDataFrameColumnArithmetic void Xor(T scalar, PrimitiveColumnContainer column); void LeftShift(PrimitiveColumnContainer column, int value); void RightShift(PrimitiveColumnContainer column, int value); - void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right); - void ElementwiseEquals(PrimitiveColumnContainer column, T scalar); - void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right); - void ElementwiseNotEquals(PrimitiveColumnContainer column, T scalar); - void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right); - void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, T scalar); - void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right); - void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, T scalar); - void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right); - void ElementwiseGreaterThan(PrimitiveColumnContainer column, T scalar); - void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right); - void ElementwiseLessThan(PrimitiveColumnContainer column, T scalar); + PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right); + PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, T scalar); + PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right); + PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, T scalar); + PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right); + PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, T scalar); + PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right); + PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, T scalar); + PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right); + PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, T scalar); + PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right); + PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, T scalar); } internal static class PrimitiveDataFrameColumnArithmetic @@ -123,69 +123,84 @@ public static IPrimitiveDataFrameColumnArithmetic GetArithmetic() throw new NotSupportedException(); } } - internal class BoolArithmetic : IPrimitiveDataFrameColumnArithmetic { + public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void Add(PrimitiveColumnContainer column, bool scalar) { throw new NotSupportedException(); } + public void Add(bool scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void Subtract(PrimitiveColumnContainer column, bool scalar) { throw new NotSupportedException(); } + public void Subtract(bool scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void Multiply(PrimitiveColumnContainer column, bool scalar) { throw new NotSupportedException(); } + public void Multiply(bool scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void Divide(PrimitiveColumnContainer column, bool scalar) { throw new NotSupportedException(); } + public void Divide(bool scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void Modulo(PrimitiveColumnContainer column, bool scalar) { throw new NotSupportedException(); } + public void Modulo(bool scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -199,6 +214,7 @@ public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer column, bool scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -211,6 +227,7 @@ public void And(PrimitiveColumnContainer column, bool scalar) } } } + public void And(bool scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -223,6 +240,7 @@ public void And(bool scalar, PrimitiveColumnContainer column) } } } + public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -236,6 +254,7 @@ public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer column, bool scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -248,6 +267,7 @@ public void Or(PrimitiveColumnContainer column, bool scalar) } } } + public void Or(bool scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -260,6 +280,7 @@ public void Or(bool scalar, PrimitiveColumnContainer column) } } } + public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -273,6 +294,7 @@ public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer column, bool scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -285,6 +307,7 @@ public void Xor(PrimitiveColumnContainer column, bool scalar) } } } + public void Xor(bool scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -297,16 +320,20 @@ public void Xor(bool scalar, PrimitiveColumnContainer column) } } } + public void LeftShift(PrimitiveColumnContainer column, int value) { throw new NotSupportedException(); } + public void RightShift(PrimitiveColumnContainer column, int value) { throw new NotSupportedException(); } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -317,9 +344,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColu ret[index++] = (span[i] == otherSpan[i]); } } + return ret; } - public void ElementwiseEquals(PrimitiveColumnContainer column, bool scalar) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, bool scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -329,9 +359,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, bool scalar ret[index++] = (span[i] == scalar); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -342,9 +375,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveC ret[index++] = (span[i] != otherSpan[i]); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, bool scalar) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, bool scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -354,42 +390,52 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, bool sca ret[index++] = (span[i] != scalar); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, bool scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, bool scalar) { throw new NotSupportedException(); } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, bool scalar) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, bool scalar) { throw new NotSupportedException(); } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, bool scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, bool scalar) { throw new NotSupportedException(); } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } - public void ElementwiseLessThan(PrimitiveColumnContainer column, bool scalar) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, bool scalar) { throw new NotSupportedException(); } } internal class ByteArithmetic : IPrimitiveDataFrameColumnArithmetic { + public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -403,6 +449,7 @@ public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer column, byte scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -415,6 +462,7 @@ public void Add(PrimitiveColumnContainer column, byte scalar) } } } + public void Add(byte scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -427,6 +475,7 @@ public void Add(byte scalar, PrimitiveColumnContainer column) } } } + public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -440,6 +489,7 @@ public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContain } } } + public void Subtract(PrimitiveColumnContainer column, byte scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -452,6 +502,7 @@ public void Subtract(PrimitiveColumnContainer column, byte scalar) } } } + public void Subtract(byte scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -464,6 +515,7 @@ public void Subtract(byte scalar, PrimitiveColumnContainer column) } } } + public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -477,6 +529,7 @@ public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContain } } } + public void Multiply(PrimitiveColumnContainer column, byte scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -489,6 +542,7 @@ public void Multiply(PrimitiveColumnContainer column, byte scalar) } } } + public void Multiply(byte scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -501,6 +555,7 @@ public void Multiply(byte scalar, PrimitiveColumnContainer column) } } } + public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -514,6 +569,7 @@ public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer } } } + public void Divide(PrimitiveColumnContainer column, byte scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -526,6 +582,7 @@ public void Divide(PrimitiveColumnContainer column, byte scalar) } } } + public void Divide(byte scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -538,6 +595,7 @@ public void Divide(byte scalar, PrimitiveColumnContainer column) } } } + public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -551,6 +609,7 @@ public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer } } } + public void Modulo(PrimitiveColumnContainer column, byte scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -563,6 +622,7 @@ public void Modulo(PrimitiveColumnContainer column, byte scalar) } } } + public void Modulo(byte scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -575,6 +635,7 @@ public void Modulo(byte scalar, PrimitiveColumnContainer column) } } } + public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -588,6 +649,7 @@ public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer column, byte scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -600,6 +662,7 @@ public void And(PrimitiveColumnContainer column, byte scalar) } } } + public void And(byte scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -612,6 +675,7 @@ public void And(byte scalar, PrimitiveColumnContainer column) } } } + public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -625,6 +689,7 @@ public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer column, byte scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -637,6 +702,7 @@ public void Or(PrimitiveColumnContainer column, byte scalar) } } } + public void Or(byte scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -649,6 +715,7 @@ public void Or(byte scalar, PrimitiveColumnContainer column) } } } + public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -662,6 +729,7 @@ public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer column, byte scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -674,6 +742,7 @@ public void Xor(PrimitiveColumnContainer column, byte scalar) } } } + public void Xor(byte scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -686,6 +755,7 @@ public void Xor(byte scalar, PrimitiveColumnContainer column) } } } + public void LeftShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) @@ -698,6 +768,7 @@ public void LeftShift(PrimitiveColumnContainer column, int value) } } } + public void RightShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) @@ -710,8 +781,10 @@ public void RightShift(PrimitiveColumnContainer column, int value) } } } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -722,9 +795,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColu ret[index++] = (span[i] == otherSpan[i]); } } + return ret; } - public void ElementwiseEquals(PrimitiveColumnContainer column, byte scalar) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, byte scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -734,9 +810,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, byte scalar ret[index++] = (span[i] == scalar); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -747,9 +826,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveC ret[index++] = (span[i] != otherSpan[i]); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, byte scalar) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, byte scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -759,9 +841,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, byte sca ret[index++] = (span[i] != scalar); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -772,9 +857,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, P ret[index++] = (span[i] >= otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, byte scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, byte scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -784,9 +872,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, ret[index++] = (span[i] >= scalar); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -797,9 +888,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Prim ret[index++] = (span[i] <= otherSpan[i]); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, byte scalar) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, byte scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -809,9 +903,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, by ret[index++] = (span[i] <= scalar); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -822,9 +919,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primitiv ret[index++] = (span[i] > otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, byte scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, byte scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -834,9 +934,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, byte s ret[index++] = (span[i] > scalar); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -847,9 +950,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveCo ret[index++] = (span[i] < otherSpan[i]); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer column, byte scalar) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, byte scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -859,10 +965,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer column, byte scal ret[index++] = (span[i] < scalar); } } + return ret; } } internal class CharArithmetic : IPrimitiveDataFrameColumnArithmetic { + public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -876,6 +984,7 @@ public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer column, char scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -888,6 +997,7 @@ public void Add(PrimitiveColumnContainer column, char scalar) } } } + public void Add(char scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -900,6 +1010,7 @@ public void Add(char scalar, PrimitiveColumnContainer column) } } } + public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -913,6 +1024,7 @@ public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContain } } } + public void Subtract(PrimitiveColumnContainer column, char scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -925,6 +1037,7 @@ public void Subtract(PrimitiveColumnContainer column, char scalar) } } } + public void Subtract(char scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -937,6 +1050,7 @@ public void Subtract(char scalar, PrimitiveColumnContainer column) } } } + public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -950,6 +1064,7 @@ public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContain } } } + public void Multiply(PrimitiveColumnContainer column, char scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -962,6 +1077,7 @@ public void Multiply(PrimitiveColumnContainer column, char scalar) } } } + public void Multiply(char scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -974,6 +1090,7 @@ public void Multiply(char scalar, PrimitiveColumnContainer column) } } } + public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -987,6 +1104,7 @@ public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer } } } + public void Divide(PrimitiveColumnContainer column, char scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -999,6 +1117,7 @@ public void Divide(PrimitiveColumnContainer column, char scalar) } } } + public void Divide(char scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1011,6 +1130,7 @@ public void Divide(char scalar, PrimitiveColumnContainer column) } } } + public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -1024,6 +1144,7 @@ public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer } } } + public void Modulo(PrimitiveColumnContainer column, char scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1036,6 +1157,7 @@ public void Modulo(PrimitiveColumnContainer column, char scalar) } } } + public void Modulo(char scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1048,6 +1170,7 @@ public void Modulo(char scalar, PrimitiveColumnContainer column) } } } + public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -1061,6 +1184,7 @@ public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer column, char scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1073,6 +1197,7 @@ public void And(PrimitiveColumnContainer column, char scalar) } } } + public void And(char scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1085,6 +1210,7 @@ public void And(char scalar, PrimitiveColumnContainer column) } } } + public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -1098,6 +1224,7 @@ public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer column, char scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1110,6 +1237,7 @@ public void Or(PrimitiveColumnContainer column, char scalar) } } } + public void Or(char scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1122,6 +1250,7 @@ public void Or(char scalar, PrimitiveColumnContainer column) } } } + public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -1135,6 +1264,7 @@ public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer column, char scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1147,6 +1277,7 @@ public void Xor(PrimitiveColumnContainer column, char scalar) } } } + public void Xor(char scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1159,6 +1290,7 @@ public void Xor(char scalar, PrimitiveColumnContainer column) } } } + public void LeftShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1171,6 +1303,7 @@ public void LeftShift(PrimitiveColumnContainer column, int value) } } } + public void RightShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1183,8 +1316,10 @@ public void RightShift(PrimitiveColumnContainer column, int value) } } } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1195,9 +1330,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColu ret[index++] = (span[i] == otherSpan[i]); } } + return ret; } - public void ElementwiseEquals(PrimitiveColumnContainer column, char scalar) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, char scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1207,9 +1345,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, char scalar ret[index++] = (span[i] == scalar); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1220,9 +1361,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveC ret[index++] = (span[i] != otherSpan[i]); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, char scalar) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, char scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1232,9 +1376,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, char sca ret[index++] = (span[i] != scalar); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1245,9 +1392,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, P ret[index++] = (span[i] >= otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, char scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, char scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1257,9 +1407,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, ret[index++] = (span[i] >= scalar); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1270,9 +1423,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Prim ret[index++] = (span[i] <= otherSpan[i]); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, char scalar) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, char scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1282,9 +1438,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ch ret[index++] = (span[i] <= scalar); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1295,9 +1454,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primitiv ret[index++] = (span[i] > otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, char scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, char scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1307,9 +1469,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, char s ret[index++] = (span[i] > scalar); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1320,9 +1485,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveCo ret[index++] = (span[i] < otherSpan[i]); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer column, char scalar) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, char scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1332,10 +1500,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer column, char scal ret[index++] = (span[i] < scalar); } } + return ret; } } internal class DecimalArithmetic : IPrimitiveDataFrameColumnArithmetic { + public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -1349,6 +1519,7 @@ public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer } } } + public void Add(PrimitiveColumnContainer column, decimal scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1361,6 +1532,7 @@ public void Add(PrimitiveColumnContainer column, decimal scalar) } } } + public void Add(decimal scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1373,6 +1545,7 @@ public void Add(decimal scalar, PrimitiveColumnContainer column) } } } + public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -1386,6 +1559,7 @@ public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnCont } } } + public void Subtract(PrimitiveColumnContainer column, decimal scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1398,6 +1572,7 @@ public void Subtract(PrimitiveColumnContainer column, decimal scalar) } } } + public void Subtract(decimal scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1410,6 +1585,7 @@ public void Subtract(decimal scalar, PrimitiveColumnContainer column) } } } + public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -1423,6 +1599,7 @@ public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnCont } } } + public void Multiply(PrimitiveColumnContainer column, decimal scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1435,6 +1612,7 @@ public void Multiply(PrimitiveColumnContainer column, decimal scalar) } } } + public void Multiply(decimal scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1447,6 +1625,7 @@ public void Multiply(decimal scalar, PrimitiveColumnContainer column) } } } + public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -1460,6 +1639,7 @@ public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContai } } } + public void Divide(PrimitiveColumnContainer column, decimal scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1472,6 +1652,7 @@ public void Divide(PrimitiveColumnContainer column, decimal scalar) } } } + public void Divide(decimal scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1484,6 +1665,7 @@ public void Divide(decimal scalar, PrimitiveColumnContainer column) } } } + public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -1497,6 +1679,7 @@ public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContai } } } + public void Modulo(PrimitiveColumnContainer column, decimal scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1509,6 +1692,7 @@ public void Modulo(PrimitiveColumnContainer column, decimal scalar) } } } + public void Modulo(decimal scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1521,52 +1705,65 @@ public void Modulo(decimal scalar, PrimitiveColumnContainer column) } } } + public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void And(PrimitiveColumnContainer column, decimal scalar) { throw new NotSupportedException(); } + public void And(decimal scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void Or(PrimitiveColumnContainer column, decimal scalar) { throw new NotSupportedException(); } + public void Or(decimal scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void Xor(PrimitiveColumnContainer column, decimal scalar) { throw new NotSupportedException(); } + public void Xor(decimal scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void LeftShift(PrimitiveColumnContainer column, int value) { throw new NotSupportedException(); } + public void RightShift(PrimitiveColumnContainer column, int value) { throw new NotSupportedException(); } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1577,9 +1774,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveC ret[index++] = (span[i] == otherSpan[i]); } } + return ret; } - public void ElementwiseEquals(PrimitiveColumnContainer column, decimal scalar) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, decimal scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1589,9 +1789,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, decimal ret[index++] = (span[i] == scalar); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1602,9 +1805,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, Primiti ret[index++] = (span[i] != otherSpan[i]); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, decimal scalar) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, decimal scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1614,9 +1820,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, decim ret[index++] = (span[i] != scalar); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1627,9 +1836,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left ret[index++] = (span[i] >= otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, decimal scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, decimal scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1639,9 +1851,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer colu ret[index++] = (span[i] >= scalar); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1652,9 +1867,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, P ret[index++] = (span[i] <= otherSpan[i]); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, decimal scalar) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, decimal scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1664,9 +1882,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ret[index++] = (span[i] <= scalar); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1677,9 +1898,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primi ret[index++] = (span[i] > otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, decimal scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, decimal scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1689,9 +1913,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, dec ret[index++] = (span[i] > scalar); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1702,9 +1929,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, Primitiv ret[index++] = (span[i] < otherSpan[i]); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer column, decimal scalar) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, decimal scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1714,10 +1944,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer column, decima ret[index++] = (span[i] < scalar); } } + return ret; } } internal class DoubleArithmetic : IPrimitiveDataFrameColumnArithmetic { + public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -1731,6 +1963,7 @@ public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer< } } } + public void Add(PrimitiveColumnContainer column, double scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1743,6 +1976,7 @@ public void Add(PrimitiveColumnContainer column, double scalar) } } } + public void Add(double scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1755,6 +1989,7 @@ public void Add(double scalar, PrimitiveColumnContainer column) } } } + public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -1768,6 +2003,7 @@ public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnConta } } } + public void Subtract(PrimitiveColumnContainer column, double scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1780,6 +2016,7 @@ public void Subtract(PrimitiveColumnContainer column, double scalar) } } } + public void Subtract(double scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1792,6 +2029,7 @@ public void Subtract(double scalar, PrimitiveColumnContainer column) } } } + public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -1805,6 +2043,7 @@ public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnConta } } } + public void Multiply(PrimitiveColumnContainer column, double scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1817,6 +2056,7 @@ public void Multiply(PrimitiveColumnContainer column, double scalar) } } } + public void Multiply(double scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1829,6 +2069,7 @@ public void Multiply(double scalar, PrimitiveColumnContainer column) } } } + public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -1842,6 +2083,7 @@ public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContain } } } + public void Divide(PrimitiveColumnContainer column, double scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1854,6 +2096,7 @@ public void Divide(PrimitiveColumnContainer column, double scalar) } } } + public void Divide(double scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1866,6 +2109,7 @@ public void Divide(double scalar, PrimitiveColumnContainer column) } } } + public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -1879,6 +2123,7 @@ public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContain } } } + public void Modulo(PrimitiveColumnContainer column, double scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1891,6 +2136,7 @@ public void Modulo(PrimitiveColumnContainer column, double scalar) } } } + public void Modulo(double scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -1903,52 +2149,65 @@ public void Modulo(double scalar, PrimitiveColumnContainer column) } } } + public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void And(PrimitiveColumnContainer column, double scalar) { throw new NotSupportedException(); } + public void And(double scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void Or(PrimitiveColumnContainer column, double scalar) { throw new NotSupportedException(); } + public void Or(double scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void Xor(PrimitiveColumnContainer column, double scalar) { throw new NotSupportedException(); } + public void Xor(double scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void LeftShift(PrimitiveColumnContainer column, int value) { throw new NotSupportedException(); } + public void RightShift(PrimitiveColumnContainer column, int value) { throw new NotSupportedException(); } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1959,9 +2218,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveCo ret[index++] = (span[i] == otherSpan[i]); } } + return ret; } - public void ElementwiseEquals(PrimitiveColumnContainer column, double scalar) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, double scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1971,9 +2233,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, double sc ret[index++] = (span[i] == scalar); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1984,9 +2249,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, Primitiv ret[index++] = (span[i] != otherSpan[i]); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, double scalar) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, double scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1996,9 +2264,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, double ret[index++] = (span[i] != scalar); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2009,9 +2280,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, ret[index++] = (span[i] >= otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, double scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, double scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2021,9 +2295,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer colum ret[index++] = (span[i] >= scalar); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2034,9 +2311,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Pr ret[index++] = (span[i] <= otherSpan[i]); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, double scalar) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, double scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2046,9 +2326,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ret[index++] = (span[i] <= scalar); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2059,9 +2342,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primit ret[index++] = (span[i] > otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, double scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, double scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2071,9 +2357,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, doub ret[index++] = (span[i] > scalar); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2084,9 +2373,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, Primitive ret[index++] = (span[i] < otherSpan[i]); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer column, double scalar) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, double scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2096,10 +2388,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer column, double ret[index++] = (span[i] < scalar); } } + return ret; } } internal class FloatArithmetic : IPrimitiveDataFrameColumnArithmetic { + public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -2113,6 +2407,7 @@ public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer column, float scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2125,6 +2420,7 @@ public void Add(PrimitiveColumnContainer column, float scalar) } } } + public void Add(float scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2137,6 +2433,7 @@ public void Add(float scalar, PrimitiveColumnContainer column) } } } + public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -2150,6 +2447,7 @@ public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContai } } } + public void Subtract(PrimitiveColumnContainer column, float scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2162,6 +2460,7 @@ public void Subtract(PrimitiveColumnContainer column, float scalar) } } } + public void Subtract(float scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2174,6 +2473,7 @@ public void Subtract(float scalar, PrimitiveColumnContainer column) } } } + public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -2187,6 +2487,7 @@ public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContai } } } + public void Multiply(PrimitiveColumnContainer column, float scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2199,6 +2500,7 @@ public void Multiply(PrimitiveColumnContainer column, float scalar) } } } + public void Multiply(float scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2211,6 +2513,7 @@ public void Multiply(float scalar, PrimitiveColumnContainer column) } } } + public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -2224,6 +2527,7 @@ public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContaine } } } + public void Divide(PrimitiveColumnContainer column, float scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2236,6 +2540,7 @@ public void Divide(PrimitiveColumnContainer column, float scalar) } } } + public void Divide(float scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2248,6 +2553,7 @@ public void Divide(float scalar, PrimitiveColumnContainer column) } } } + public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -2261,6 +2567,7 @@ public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContaine } } } + public void Modulo(PrimitiveColumnContainer column, float scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2273,6 +2580,7 @@ public void Modulo(PrimitiveColumnContainer column, float scalar) } } } + public void Modulo(float scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2285,52 +2593,65 @@ public void Modulo(float scalar, PrimitiveColumnContainer column) } } } + public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void And(PrimitiveColumnContainer column, float scalar) { throw new NotSupportedException(); } + public void And(float scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void Or(PrimitiveColumnContainer column, float scalar) { throw new NotSupportedException(); } + public void Or(float scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void Xor(PrimitiveColumnContainer column, float scalar) { throw new NotSupportedException(); } + public void Xor(float scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void LeftShift(PrimitiveColumnContainer column, int value) { throw new NotSupportedException(); } + public void RightShift(PrimitiveColumnContainer column, int value) { throw new NotSupportedException(); } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2341,9 +2662,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveCol ret[index++] = (span[i] == otherSpan[i]); } } + return ret; } - public void ElementwiseEquals(PrimitiveColumnContainer column, float scalar) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, float scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2353,9 +2677,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, float scal ret[index++] = (span[i] == scalar); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2366,9 +2693,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, Primitive ret[index++] = (span[i] != otherSpan[i]); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, float scalar) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, float scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2378,9 +2708,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, float s ret[index++] = (span[i] != scalar); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2391,9 +2724,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, ret[index++] = (span[i] >= otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, float scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, float scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2403,9 +2739,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column ret[index++] = (span[i] >= scalar); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2416,9 +2755,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Pri ret[index++] = (span[i] <= otherSpan[i]); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, float scalar) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, float scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2428,9 +2770,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, f ret[index++] = (span[i] <= scalar); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2441,9 +2786,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primiti ret[index++] = (span[i] > otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, float scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, float scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2453,9 +2801,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, float ret[index++] = (span[i] > scalar); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2466,9 +2817,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveC ret[index++] = (span[i] < otherSpan[i]); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer column, float scalar) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, float scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2478,10 +2832,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer column, float sc ret[index++] = (span[i] < scalar); } } + return ret; } } internal class IntArithmetic : IPrimitiveDataFrameColumnArithmetic { + public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -2495,6 +2851,7 @@ public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer column, int scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2507,6 +2864,7 @@ public void Add(PrimitiveColumnContainer column, int scalar) } } } + public void Add(int scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2519,6 +2877,7 @@ public void Add(int scalar, PrimitiveColumnContainer column) } } } + public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -2532,6 +2891,7 @@ public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContaine } } } + public void Subtract(PrimitiveColumnContainer column, int scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2544,6 +2904,7 @@ public void Subtract(PrimitiveColumnContainer column, int scalar) } } } + public void Subtract(int scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2556,6 +2917,7 @@ public void Subtract(int scalar, PrimitiveColumnContainer column) } } } + public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -2569,6 +2931,7 @@ public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContaine } } } + public void Multiply(PrimitiveColumnContainer column, int scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2581,6 +2944,7 @@ public void Multiply(PrimitiveColumnContainer column, int scalar) } } } + public void Multiply(int scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2593,6 +2957,7 @@ public void Multiply(int scalar, PrimitiveColumnContainer column) } } } + public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -2606,6 +2971,7 @@ public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer< } } } + public void Divide(PrimitiveColumnContainer column, int scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2618,6 +2984,7 @@ public void Divide(PrimitiveColumnContainer column, int scalar) } } } + public void Divide(int scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2630,6 +2997,7 @@ public void Divide(int scalar, PrimitiveColumnContainer column) } } } + public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -2643,6 +3011,7 @@ public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer< } } } + public void Modulo(PrimitiveColumnContainer column, int scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2655,6 +3024,7 @@ public void Modulo(PrimitiveColumnContainer column, int scalar) } } } + public void Modulo(int scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2667,6 +3037,7 @@ public void Modulo(int scalar, PrimitiveColumnContainer column) } } } + public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -2680,6 +3051,7 @@ public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer column, int scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2692,6 +3064,7 @@ public void And(PrimitiveColumnContainer column, int scalar) } } } + public void And(int scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2704,6 +3077,7 @@ public void And(int scalar, PrimitiveColumnContainer column) } } } + public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -2717,6 +3091,7 @@ public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer } } } + public void Or(PrimitiveColumnContainer column, int scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2729,6 +3104,7 @@ public void Or(PrimitiveColumnContainer column, int scalar) } } } + public void Or(int scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2741,6 +3117,7 @@ public void Or(int scalar, PrimitiveColumnContainer column) } } } + public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -2754,6 +3131,7 @@ public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer column, int scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2766,6 +3144,7 @@ public void Xor(PrimitiveColumnContainer column, int scalar) } } } + public void Xor(int scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2778,6 +3157,7 @@ public void Xor(int scalar, PrimitiveColumnContainer column) } } } + public void LeftShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2790,6 +3170,7 @@ public void LeftShift(PrimitiveColumnContainer column, int value) } } } + public void RightShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2802,8 +3183,10 @@ public void RightShift(PrimitiveColumnContainer column, int value) } } } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2814,9 +3197,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColum ret[index++] = (span[i] == otherSpan[i]); } } + return ret; } - public void ElementwiseEquals(PrimitiveColumnContainer column, int scalar) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, int scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2826,9 +3212,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, int scalar) ret[index++] = (span[i] == scalar); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2839,9 +3228,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveCo ret[index++] = (span[i] != otherSpan[i]); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, int scalar) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, int scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2851,9 +3243,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, int scala ret[index++] = (span[i] != scalar); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2864,9 +3259,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, Pr ret[index++] = (span[i] >= otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, int scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, int scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2876,9 +3274,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, ret[index++] = (span[i] >= scalar); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2889,9 +3290,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Primi ret[index++] = (span[i] <= otherSpan[i]); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, int scalar) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, int scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2901,9 +3305,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, int ret[index++] = (span[i] <= scalar); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2914,9 +3321,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primitive ret[index++] = (span[i] > otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, int scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, int scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2926,9 +3336,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, int sca ret[index++] = (span[i] > scalar); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2939,9 +3352,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveCol ret[index++] = (span[i] < otherSpan[i]); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer column, int scalar) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, int scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2951,10 +3367,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer column, int scalar ret[index++] = (span[i] < scalar); } } + return ret; } } internal class LongArithmetic : IPrimitiveDataFrameColumnArithmetic { + public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -2968,6 +3386,7 @@ public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer column, long scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2980,6 +3399,7 @@ public void Add(PrimitiveColumnContainer column, long scalar) } } } + public void Add(long scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -2992,6 +3412,7 @@ public void Add(long scalar, PrimitiveColumnContainer column) } } } + public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -3005,6 +3426,7 @@ public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContain } } } + public void Subtract(PrimitiveColumnContainer column, long scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3017,6 +3439,7 @@ public void Subtract(PrimitiveColumnContainer column, long scalar) } } } + public void Subtract(long scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3029,6 +3452,7 @@ public void Subtract(long scalar, PrimitiveColumnContainer column) } } } + public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -3042,6 +3466,7 @@ public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContain } } } + public void Multiply(PrimitiveColumnContainer column, long scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3054,6 +3479,7 @@ public void Multiply(PrimitiveColumnContainer column, long scalar) } } } + public void Multiply(long scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3066,6 +3492,7 @@ public void Multiply(long scalar, PrimitiveColumnContainer column) } } } + public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -3079,6 +3506,7 @@ public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer } } } + public void Divide(PrimitiveColumnContainer column, long scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3091,6 +3519,7 @@ public void Divide(PrimitiveColumnContainer column, long scalar) } } } + public void Divide(long scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3103,6 +3532,7 @@ public void Divide(long scalar, PrimitiveColumnContainer column) } } } + public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -3116,6 +3546,7 @@ public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer } } } + public void Modulo(PrimitiveColumnContainer column, long scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3128,6 +3559,7 @@ public void Modulo(PrimitiveColumnContainer column, long scalar) } } } + public void Modulo(long scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3140,6 +3572,7 @@ public void Modulo(long scalar, PrimitiveColumnContainer column) } } } + public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -3153,6 +3586,7 @@ public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer column, long scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3165,6 +3599,7 @@ public void And(PrimitiveColumnContainer column, long scalar) } } } + public void And(long scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3177,6 +3612,7 @@ public void And(long scalar, PrimitiveColumnContainer column) } } } + public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -3190,6 +3626,7 @@ public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer column, long scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3202,6 +3639,7 @@ public void Or(PrimitiveColumnContainer column, long scalar) } } } + public void Or(long scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3214,6 +3652,7 @@ public void Or(long scalar, PrimitiveColumnContainer column) } } } + public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -3227,6 +3666,7 @@ public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer column, long scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3239,6 +3679,7 @@ public void Xor(PrimitiveColumnContainer column, long scalar) } } } + public void Xor(long scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3251,6 +3692,7 @@ public void Xor(long scalar, PrimitiveColumnContainer column) } } } + public void LeftShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3263,6 +3705,7 @@ public void LeftShift(PrimitiveColumnContainer column, int value) } } } + public void RightShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3275,8 +3718,10 @@ public void RightShift(PrimitiveColumnContainer column, int value) } } } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3287,9 +3732,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColu ret[index++] = (span[i] == otherSpan[i]); } } + return ret; } - public void ElementwiseEquals(PrimitiveColumnContainer column, long scalar) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, long scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3299,9 +3747,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, long scalar ret[index++] = (span[i] == scalar); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3312,9 +3763,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveC ret[index++] = (span[i] != otherSpan[i]); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, long scalar) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, long scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3324,9 +3778,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, long sca ret[index++] = (span[i] != scalar); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3337,9 +3794,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, P ret[index++] = (span[i] >= otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, long scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, long scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3349,9 +3809,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, ret[index++] = (span[i] >= scalar); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3362,9 +3825,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Prim ret[index++] = (span[i] <= otherSpan[i]); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, long scalar) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, long scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3374,9 +3840,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, lo ret[index++] = (span[i] <= scalar); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3387,9 +3856,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primitiv ret[index++] = (span[i] > otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, long scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, long scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3399,9 +3871,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, long s ret[index++] = (span[i] > scalar); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3412,9 +3887,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveCo ret[index++] = (span[i] < otherSpan[i]); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer column, long scalar) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, long scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3424,10 +3902,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer column, long scal ret[index++] = (span[i] < scalar); } } + return ret; } } internal class SByteArithmetic : IPrimitiveDataFrameColumnArithmetic { + public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -3441,6 +3921,7 @@ public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer column, sbyte scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3453,6 +3934,7 @@ public void Add(PrimitiveColumnContainer column, sbyte scalar) } } } + public void Add(sbyte scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3465,6 +3947,7 @@ public void Add(sbyte scalar, PrimitiveColumnContainer column) } } } + public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -3478,6 +3961,7 @@ public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContai } } } + public void Subtract(PrimitiveColumnContainer column, sbyte scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3490,6 +3974,7 @@ public void Subtract(PrimitiveColumnContainer column, sbyte scalar) } } } + public void Subtract(sbyte scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3502,6 +3987,7 @@ public void Subtract(sbyte scalar, PrimitiveColumnContainer column) } } } + public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -3515,6 +4001,7 @@ public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContai } } } + public void Multiply(PrimitiveColumnContainer column, sbyte scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3527,6 +4014,7 @@ public void Multiply(PrimitiveColumnContainer column, sbyte scalar) } } } + public void Multiply(sbyte scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3539,6 +4027,7 @@ public void Multiply(sbyte scalar, PrimitiveColumnContainer column) } } } + public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -3552,6 +4041,7 @@ public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContaine } } } + public void Divide(PrimitiveColumnContainer column, sbyte scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3564,6 +4054,7 @@ public void Divide(PrimitiveColumnContainer column, sbyte scalar) } } } + public void Divide(sbyte scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3576,6 +4067,7 @@ public void Divide(sbyte scalar, PrimitiveColumnContainer column) } } } + public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -3589,6 +4081,7 @@ public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContaine } } } + public void Modulo(PrimitiveColumnContainer column, sbyte scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3601,6 +4094,7 @@ public void Modulo(PrimitiveColumnContainer column, sbyte scalar) } } } + public void Modulo(sbyte scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3613,6 +4107,7 @@ public void Modulo(sbyte scalar, PrimitiveColumnContainer column) } } } + public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -3626,6 +4121,7 @@ public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer column, sbyte scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3638,6 +4134,7 @@ public void And(PrimitiveColumnContainer column, sbyte scalar) } } } + public void And(sbyte scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3650,6 +4147,7 @@ public void And(sbyte scalar, PrimitiveColumnContainer column) } } } + public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -3663,6 +4161,7 @@ public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer column, sbyte scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3675,6 +4174,7 @@ public void Or(PrimitiveColumnContainer column, sbyte scalar) } } } + public void Or(sbyte scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3687,6 +4187,7 @@ public void Or(sbyte scalar, PrimitiveColumnContainer column) } } } + public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -3700,6 +4201,7 @@ public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer column, sbyte scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3712,6 +4214,7 @@ public void Xor(PrimitiveColumnContainer column, sbyte scalar) } } } + public void Xor(sbyte scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3724,6 +4227,7 @@ public void Xor(sbyte scalar, PrimitiveColumnContainer column) } } } + public void LeftShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3736,6 +4240,7 @@ public void LeftShift(PrimitiveColumnContainer column, int value) } } } + public void RightShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3748,8 +4253,10 @@ public void RightShift(PrimitiveColumnContainer column, int value) } } } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3760,9 +4267,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveCol ret[index++] = (span[i] == otherSpan[i]); } } + return ret; } - public void ElementwiseEquals(PrimitiveColumnContainer column, sbyte scalar) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, sbyte scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3772,9 +4282,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, sbyte scal ret[index++] = (span[i] == scalar); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3785,9 +4298,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, Primitive ret[index++] = (span[i] != otherSpan[i]); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, sbyte scalar) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, sbyte scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3797,9 +4313,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, sbyte s ret[index++] = (span[i] != scalar); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3810,9 +4329,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, ret[index++] = (span[i] >= otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, sbyte scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, sbyte scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3822,9 +4344,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column ret[index++] = (span[i] >= scalar); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3835,9 +4360,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Pri ret[index++] = (span[i] <= otherSpan[i]); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, sbyte scalar) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, sbyte scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3847,9 +4375,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, s ret[index++] = (span[i] <= scalar); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3860,9 +4391,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primiti ret[index++] = (span[i] > otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, sbyte scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, sbyte scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3872,9 +4406,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, sbyte ret[index++] = (span[i] > scalar); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3885,9 +4422,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveC ret[index++] = (span[i] < otherSpan[i]); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer column, sbyte scalar) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, sbyte scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3897,10 +4437,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer column, sbyte sc ret[index++] = (span[i] < scalar); } } + return ret; } } internal class ShortArithmetic : IPrimitiveDataFrameColumnArithmetic { + public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -3914,6 +4456,7 @@ public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer column, short scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3926,6 +4469,7 @@ public void Add(PrimitiveColumnContainer column, short scalar) } } } + public void Add(short scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3938,6 +4482,7 @@ public void Add(short scalar, PrimitiveColumnContainer column) } } } + public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -3951,6 +4496,7 @@ public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContai } } } + public void Subtract(PrimitiveColumnContainer column, short scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3963,6 +4509,7 @@ public void Subtract(PrimitiveColumnContainer column, short scalar) } } } + public void Subtract(short scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -3975,6 +4522,7 @@ public void Subtract(short scalar, PrimitiveColumnContainer column) } } } + public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -3988,6 +4536,7 @@ public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContai } } } + public void Multiply(PrimitiveColumnContainer column, short scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4000,6 +4549,7 @@ public void Multiply(PrimitiveColumnContainer column, short scalar) } } } + public void Multiply(short scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4012,6 +4562,7 @@ public void Multiply(short scalar, PrimitiveColumnContainer column) } } } + public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -4025,6 +4576,7 @@ public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContaine } } } + public void Divide(PrimitiveColumnContainer column, short scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4037,6 +4589,7 @@ public void Divide(PrimitiveColumnContainer column, short scalar) } } } + public void Divide(short scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4049,6 +4602,7 @@ public void Divide(short scalar, PrimitiveColumnContainer column) } } } + public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -4062,6 +4616,7 @@ public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContaine } } } + public void Modulo(PrimitiveColumnContainer column, short scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4074,6 +4629,7 @@ public void Modulo(PrimitiveColumnContainer column, short scalar) } } } + public void Modulo(short scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4086,6 +4642,7 @@ public void Modulo(short scalar, PrimitiveColumnContainer column) } } } + public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -4099,6 +4656,7 @@ public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer column, short scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4111,6 +4669,7 @@ public void And(PrimitiveColumnContainer column, short scalar) } } } + public void And(short scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4123,6 +4682,7 @@ public void And(short scalar, PrimitiveColumnContainer column) } } } + public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -4136,6 +4696,7 @@ public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer column, short scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4148,6 +4709,7 @@ public void Or(PrimitiveColumnContainer column, short scalar) } } } + public void Or(short scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4160,6 +4722,7 @@ public void Or(short scalar, PrimitiveColumnContainer column) } } } + public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -4173,6 +4736,7 @@ public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer column, short scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4185,6 +4749,7 @@ public void Xor(PrimitiveColumnContainer column, short scalar) } } } + public void Xor(short scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4197,6 +4762,7 @@ public void Xor(short scalar, PrimitiveColumnContainer column) } } } + public void LeftShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4209,6 +4775,7 @@ public void LeftShift(PrimitiveColumnContainer column, int value) } } } + public void RightShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4221,8 +4788,10 @@ public void RightShift(PrimitiveColumnContainer column, int value) } } } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4233,9 +4802,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveCol ret[index++] = (span[i] == otherSpan[i]); } } + return ret; } - public void ElementwiseEquals(PrimitiveColumnContainer column, short scalar) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, short scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4245,9 +4817,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, short scal ret[index++] = (span[i] == scalar); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4258,9 +4833,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, Primitive ret[index++] = (span[i] != otherSpan[i]); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, short scalar) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, short scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4270,9 +4848,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, short s ret[index++] = (span[i] != scalar); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4283,9 +4864,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, ret[index++] = (span[i] >= otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, short scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, short scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4295,9 +4879,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column ret[index++] = (span[i] >= scalar); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4308,9 +4895,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Pri ret[index++] = (span[i] <= otherSpan[i]); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, short scalar) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, short scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4320,9 +4910,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, s ret[index++] = (span[i] <= scalar); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4333,9 +4926,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primiti ret[index++] = (span[i] > otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, short scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, short scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4345,9 +4941,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, short ret[index++] = (span[i] > scalar); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4358,9 +4957,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveC ret[index++] = (span[i] < otherSpan[i]); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer column, short scalar) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, short scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4370,10 +4972,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer column, short sc ret[index++] = (span[i] < scalar); } } + return ret; } } internal class UIntArithmetic : IPrimitiveDataFrameColumnArithmetic { + public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -4387,6 +4991,7 @@ public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer column, uint scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4399,6 +5004,7 @@ public void Add(PrimitiveColumnContainer column, uint scalar) } } } + public void Add(uint scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4411,6 +5017,7 @@ public void Add(uint scalar, PrimitiveColumnContainer column) } } } + public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -4424,6 +5031,7 @@ public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContain } } } + public void Subtract(PrimitiveColumnContainer column, uint scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4436,6 +5044,7 @@ public void Subtract(PrimitiveColumnContainer column, uint scalar) } } } + public void Subtract(uint scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4448,6 +5057,7 @@ public void Subtract(uint scalar, PrimitiveColumnContainer column) } } } + public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -4461,6 +5071,7 @@ public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContain } } } + public void Multiply(PrimitiveColumnContainer column, uint scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4473,6 +5084,7 @@ public void Multiply(PrimitiveColumnContainer column, uint scalar) } } } + public void Multiply(uint scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4485,6 +5097,7 @@ public void Multiply(uint scalar, PrimitiveColumnContainer column) } } } + public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -4498,6 +5111,7 @@ public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer } } } + public void Divide(PrimitiveColumnContainer column, uint scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4510,6 +5124,7 @@ public void Divide(PrimitiveColumnContainer column, uint scalar) } } } + public void Divide(uint scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4522,6 +5137,7 @@ public void Divide(uint scalar, PrimitiveColumnContainer column) } } } + public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -4535,6 +5151,7 @@ public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer } } } + public void Modulo(PrimitiveColumnContainer column, uint scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4547,6 +5164,7 @@ public void Modulo(PrimitiveColumnContainer column, uint scalar) } } } + public void Modulo(uint scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4559,6 +5177,7 @@ public void Modulo(uint scalar, PrimitiveColumnContainer column) } } } + public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -4572,6 +5191,7 @@ public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer column, uint scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4584,6 +5204,7 @@ public void And(PrimitiveColumnContainer column, uint scalar) } } } + public void And(uint scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4596,6 +5217,7 @@ public void And(uint scalar, PrimitiveColumnContainer column) } } } + public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -4609,6 +5231,7 @@ public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer column, uint scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4621,6 +5244,7 @@ public void Or(PrimitiveColumnContainer column, uint scalar) } } } + public void Or(uint scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4633,6 +5257,7 @@ public void Or(uint scalar, PrimitiveColumnContainer column) } } } + public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -4646,6 +5271,7 @@ public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer column, uint scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4658,6 +5284,7 @@ public void Xor(PrimitiveColumnContainer column, uint scalar) } } } + public void Xor(uint scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4670,6 +5297,7 @@ public void Xor(uint scalar, PrimitiveColumnContainer column) } } } + public void LeftShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4682,6 +5310,7 @@ public void LeftShift(PrimitiveColumnContainer column, int value) } } } + public void RightShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4694,8 +5323,10 @@ public void RightShift(PrimitiveColumnContainer column, int value) } } } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4706,9 +5337,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColu ret[index++] = (span[i] == otherSpan[i]); } } + return ret; } - public void ElementwiseEquals(PrimitiveColumnContainer column, uint scalar) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, uint scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4718,9 +5352,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, uint scalar ret[index++] = (span[i] == scalar); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4731,9 +5368,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveC ret[index++] = (span[i] != otherSpan[i]); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, uint scalar) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, uint scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4743,9 +5383,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, uint sca ret[index++] = (span[i] != scalar); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4756,9 +5399,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, P ret[index++] = (span[i] >= otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, uint scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, uint scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4768,9 +5414,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, ret[index++] = (span[i] >= scalar); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4781,9 +5430,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Prim ret[index++] = (span[i] <= otherSpan[i]); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, uint scalar) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, uint scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4793,9 +5445,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ui ret[index++] = (span[i] <= scalar); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4806,9 +5461,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primitiv ret[index++] = (span[i] > otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, uint scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, uint scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4818,9 +5476,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, uint s ret[index++] = (span[i] > scalar); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4831,9 +5492,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveCo ret[index++] = (span[i] < otherSpan[i]); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer column, uint scalar) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, uint scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4843,10 +5507,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer column, uint scal ret[index++] = (span[i] < scalar); } } + return ret; } } internal class ULongArithmetic : IPrimitiveDataFrameColumnArithmetic { + public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -4860,6 +5526,7 @@ public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer column, ulong scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4872,6 +5539,7 @@ public void Add(PrimitiveColumnContainer column, ulong scalar) } } } + public void Add(ulong scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4884,6 +5552,7 @@ public void Add(ulong scalar, PrimitiveColumnContainer column) } } } + public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -4897,6 +5566,7 @@ public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContai } } } + public void Subtract(PrimitiveColumnContainer column, ulong scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4909,6 +5579,7 @@ public void Subtract(PrimitiveColumnContainer column, ulong scalar) } } } + public void Subtract(ulong scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4921,6 +5592,7 @@ public void Subtract(ulong scalar, PrimitiveColumnContainer column) } } } + public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -4934,6 +5606,7 @@ public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContai } } } + public void Multiply(PrimitiveColumnContainer column, ulong scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4946,6 +5619,7 @@ public void Multiply(PrimitiveColumnContainer column, ulong scalar) } } } + public void Multiply(ulong scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4958,6 +5632,7 @@ public void Multiply(ulong scalar, PrimitiveColumnContainer column) } } } + public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -4971,6 +5646,7 @@ public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContaine } } } + public void Divide(PrimitiveColumnContainer column, ulong scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4983,6 +5659,7 @@ public void Divide(PrimitiveColumnContainer column, ulong scalar) } } } + public void Divide(ulong scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -4995,6 +5672,7 @@ public void Divide(ulong scalar, PrimitiveColumnContainer column) } } } + public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -5008,6 +5686,7 @@ public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContaine } } } + public void Modulo(PrimitiveColumnContainer column, ulong scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5020,6 +5699,7 @@ public void Modulo(PrimitiveColumnContainer column, ulong scalar) } } } + public void Modulo(ulong scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5032,6 +5712,7 @@ public void Modulo(ulong scalar, PrimitiveColumnContainer column) } } } + public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -5045,6 +5726,7 @@ public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer column, ulong scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5057,6 +5739,7 @@ public void And(PrimitiveColumnContainer column, ulong scalar) } } } + public void And(ulong scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5069,6 +5752,7 @@ public void And(ulong scalar, PrimitiveColumnContainer column) } } } + public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -5082,6 +5766,7 @@ public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer
    column, ulong scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5094,6 +5779,7 @@ public void Or(PrimitiveColumnContainer column, ulong scalar) } } } + public void Or(ulong scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5106,6 +5792,7 @@ public void Or(ulong scalar, PrimitiveColumnContainer column) } } } + public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -5119,6 +5806,7 @@ public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer column, ulong scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5131,6 +5819,7 @@ public void Xor(PrimitiveColumnContainer column, ulong scalar) } } } + public void Xor(ulong scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5143,6 +5832,7 @@ public void Xor(ulong scalar, PrimitiveColumnContainer column) } } } + public void LeftShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5155,6 +5845,7 @@ public void LeftShift(PrimitiveColumnContainer column, int value) } } } + public void RightShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5167,8 +5858,10 @@ public void RightShift(PrimitiveColumnContainer column, int value) } } } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5179,9 +5872,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveCol ret[index++] = (span[i] == otherSpan[i]); } } + return ret; } - public void ElementwiseEquals(PrimitiveColumnContainer column, ulong scalar) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, ulong scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5191,9 +5887,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, ulong scal ret[index++] = (span[i] == scalar); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5204,9 +5903,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, Primitive ret[index++] = (span[i] != otherSpan[i]); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, ulong scalar) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, ulong scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5216,9 +5918,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, ulong s ret[index++] = (span[i] != scalar); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5229,9 +5934,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, ret[index++] = (span[i] >= otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, ulong scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, ulong scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5241,9 +5949,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column ret[index++] = (span[i] >= scalar); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5254,9 +5965,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Pri ret[index++] = (span[i] <= otherSpan[i]); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ulong scalar) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ulong scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5266,9 +5980,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, u ret[index++] = (span[i] <= scalar); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5279,9 +5996,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primiti ret[index++] = (span[i] > otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, ulong scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, ulong scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5291,9 +6011,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, ulong ret[index++] = (span[i] > scalar); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5304,9 +6027,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveC ret[index++] = (span[i] < otherSpan[i]); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer column, ulong scalar) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, ulong scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5316,10 +6042,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer column, ulong sc ret[index++] = (span[i] < scalar); } } + return ret; } } internal class UShortArithmetic : IPrimitiveDataFrameColumnArithmetic { + public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -5333,6 +6061,7 @@ public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer< } } } + public void Add(PrimitiveColumnContainer column, ushort scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5345,6 +6074,7 @@ public void Add(PrimitiveColumnContainer column, ushort scalar) } } } + public void Add(ushort scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5357,6 +6087,7 @@ public void Add(ushort scalar, PrimitiveColumnContainer column) } } } + public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -5370,6 +6101,7 @@ public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnConta } } } + public void Subtract(PrimitiveColumnContainer column, ushort scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5382,6 +6114,7 @@ public void Subtract(PrimitiveColumnContainer column, ushort scalar) } } } + public void Subtract(ushort scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5394,6 +6127,7 @@ public void Subtract(ushort scalar, PrimitiveColumnContainer column) } } } + public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -5407,6 +6141,7 @@ public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnConta } } } + public void Multiply(PrimitiveColumnContainer column, ushort scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5419,6 +6154,7 @@ public void Multiply(PrimitiveColumnContainer column, ushort scalar) } } } + public void Multiply(ushort scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5431,6 +6167,7 @@ public void Multiply(ushort scalar, PrimitiveColumnContainer column) } } } + public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -5444,6 +6181,7 @@ public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContain } } } + public void Divide(PrimitiveColumnContainer column, ushort scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5456,6 +6194,7 @@ public void Divide(PrimitiveColumnContainer column, ushort scalar) } } } + public void Divide(ushort scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5468,6 +6207,7 @@ public void Divide(ushort scalar, PrimitiveColumnContainer column) } } } + public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -5481,6 +6221,7 @@ public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContain } } } + public void Modulo(PrimitiveColumnContainer column, ushort scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5493,6 +6234,7 @@ public void Modulo(PrimitiveColumnContainer column, ushort scalar) } } } + public void Modulo(ushort scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5505,6 +6247,7 @@ public void Modulo(ushort scalar, PrimitiveColumnContainer column) } } } + public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -5518,6 +6261,7 @@ public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer< } } } + public void And(PrimitiveColumnContainer column, ushort scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5530,6 +6274,7 @@ public void And(PrimitiveColumnContainer column, ushort scalar) } } } + public void And(ushort scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5542,6 +6287,7 @@ public void And(ushort scalar, PrimitiveColumnContainer column) } } } + public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -5555,6 +6301,7 @@ public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer column, ushort scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5567,6 +6314,7 @@ public void Or(PrimitiveColumnContainer column, ushort scalar) } } } + public void Or(ushort scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5579,6 +6327,7 @@ public void Or(ushort scalar, PrimitiveColumnContainer column) } } } + public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -5592,6 +6341,7 @@ public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer< } } } + public void Xor(PrimitiveColumnContainer column, ushort scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5604,6 +6354,7 @@ public void Xor(PrimitiveColumnContainer column, ushort scalar) } } } + public void Xor(ushort scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5616,6 +6367,7 @@ public void Xor(ushort scalar, PrimitiveColumnContainer column) } } } + public void LeftShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5628,6 +6380,7 @@ public void LeftShift(PrimitiveColumnContainer column, int value) } } } + public void RightShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) @@ -5640,8 +6393,10 @@ public void RightShift(PrimitiveColumnContainer column, int value) } } } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5652,9 +6407,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveCo ret[index++] = (span[i] == otherSpan[i]); } } + return ret; } - public void ElementwiseEquals(PrimitiveColumnContainer column, ushort scalar) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, ushort scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5664,9 +6422,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, ushort sc ret[index++] = (span[i] == scalar); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5677,9 +6438,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, Primitiv ret[index++] = (span[i] != otherSpan[i]); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, ushort scalar) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, ushort scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5689,9 +6453,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, ushort ret[index++] = (span[i] != scalar); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5702,9 +6469,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, ret[index++] = (span[i] >= otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, ushort scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, ushort scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5714,9 +6484,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer colum ret[index++] = (span[i] >= scalar); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5727,9 +6500,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Pr ret[index++] = (span[i] <= otherSpan[i]); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ushort scalar) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ushort scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5739,9 +6515,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ret[index++] = (span[i] <= scalar); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5752,9 +6531,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, Primit ret[index++] = (span[i] > otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, ushort scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, ushort scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5764,9 +6546,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, usho ret[index++] = (span[i] > scalar); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5777,9 +6562,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, Primitive ret[index++] = (span[i] < otherSpan[i]); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer column, ushort scalar) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, ushort scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5789,116 +6577,145 @@ public void ElementwiseLessThan(PrimitiveColumnContainer column, ushort ret[index++] = (span[i] < scalar); } } + return ret; } } internal class DateTimeArithmetic : IPrimitiveDataFrameColumnArithmetic { + public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void Add(PrimitiveColumnContainer column, DateTime scalar) { throw new NotSupportedException(); } + public void Add(DateTime scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void Subtract(PrimitiveColumnContainer column, DateTime scalar) { throw new NotSupportedException(); } + public void Subtract(DateTime scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void Multiply(PrimitiveColumnContainer column, DateTime scalar) { throw new NotSupportedException(); } + public void Multiply(DateTime scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void Divide(PrimitiveColumnContainer column, DateTime scalar) { throw new NotSupportedException(); } + public void Divide(DateTime scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void Modulo(PrimitiveColumnContainer column, DateTime scalar) { throw new NotSupportedException(); } + public void Modulo(DateTime scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void And(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void And(PrimitiveColumnContainer column, DateTime scalar) { throw new NotSupportedException(); } + public void And(DateTime scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void Or(PrimitiveColumnContainer column, DateTime scalar) { throw new NotSupportedException(); } + public void Or(DateTime scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public void Xor(PrimitiveColumnContainer column, DateTime scalar) { throw new NotSupportedException(); } + public void Xor(DateTime scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public void LeftShift(PrimitiveColumnContainer column, int value) { throw new NotSupportedException(); } + public void RightShift(PrimitiveColumnContainer column, int value) { throw new NotSupportedException(); } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5909,9 +6726,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, Primitive ret[index++] = (span[i] == otherSpan[i]); } } + return ret; } - public void ElementwiseEquals(PrimitiveColumnContainer column, DateTime scalar) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, DateTime scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5921,9 +6741,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, DateTim ret[index++] = (span[i] == scalar); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5934,9 +6757,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, Primit ret[index++] = (span[i] != otherSpan[i]); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, DateTime scalar) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, DateTime scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5946,36 +6772,45 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, Date ret[index++] = (span[i] != scalar); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, DateTime scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, DateTime scalar) { throw new NotSupportedException(); } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, DateTime scalar) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, DateTime scalar) { throw new NotSupportedException(); } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, DateTime scalar) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, DateTime scalar) { throw new NotSupportedException(); } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } - public void ElementwiseLessThan(PrimitiveColumnContainer column, DateTime scalar) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, DateTime scalar) { throw new NotSupportedException(); } diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt index 790eb2bfca..d158295b1a 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt @@ -21,7 +21,11 @@ namespace Microsoft.Data.Analysis where T : unmanaged { <# foreach (MethodConfiguration method in methodConfiguration) { #> +<# if (method.MethodType == MethodType.Comparison || method.MethodType == MethodType.ComparisonScalar) { #> + PrimitiveColumnContainer <#=method.MethodName#>(<#=method.GetMethodArguments("PrimitiveColumnContainer", "T")#>); +<#} else {#> void <#=method.MethodName#>(<#=method.GetMethodArguments("PrimitiveColumnContainer", "T")#>); +<# } #> <# if (method.MethodType == MethodType.BinaryScalar) { #> <#= method.GetInvertedMethodSignatureForBinaryScalarsOps("PrimitiveColumnContainer", "T")#>; <# } #> @@ -48,17 +52,24 @@ namespace Microsoft.Data.Analysis throw new NotSupportedException(); } } - <# foreach (TypeConfiguration type in typeConfiguration) { #> internal class <#=type.ClassPrefix#>Arithmetic : IPrimitiveDataFrameColumnArithmetic<<#=type.TypeName#>> { <# foreach (MethodConfiguration method in methodConfiguration) { #> +<# if (method.MethodType == MethodType.Comparison || method.MethodType == MethodType.ComparisonScalar) { #> + + public PrimitiveColumnContainer <#=method.MethodName#>(<#=method.GetMethodArguments("PrimitiveColumnContainer", type.TypeName)#>) + { +<#} else {#> + public void <#=method.MethodName#>(<#=method.GetMethodArguments("PrimitiveColumnContainer", type.TypeName)#>) { +<# } #> <# if ((method.IsNumeric && !type.SupportsNumeric) || (method.IsBitwise && !type.SupportsBitwise) || (type.UnsupportedMethods.Contains(method.MethodName))) { #> throw new NotSupportedException(); <# } else if (method.Operator != null) { #> <# if (method.MethodType == MethodType.Comparison || method.MethodType == MethodType.ComparisonScalar) { #> + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); long index = 0; <# } #> for (int b = 0; b < <#= method.Op1Name #>.Buffers.Count; b++) @@ -90,9 +101,13 @@ namespace Microsoft.Data.Analysis <# } #> } } +<# if (method.MethodType == MethodType.Comparison || method.MethodType == MethodType.ComparisonScalar) { #> + return ret; +<# } #> <# } #> } <# if (method.MethodType == MethodType.BinaryScalar) { #> + public <#= method.GetInvertedMethodSignatureForBinaryScalarsOps("PrimitiveColumnContainer", type.TypeName) #> { <# if ((method.IsNumeric && !type.SupportsNumeric) || (method.IsBitwise && !type.SupportsBitwise) || (type.UnsupportedMethods.Contains(method.MethodName))) { #> From cbbf282e4fea73a1f6ced3c32a8d7fd8a2a5d07e Mon Sep 17 00:00:00 2001 From: Aleksei Smirnov Date: Thu, 13 Jul 2023 18:02:24 +0300 Subject: [PATCH 14/18] Change DataFrameColumn Operations --- .../ColumnArithmeticTemplate.ttinclude | 1 - .../DataFrameColumn.BinaryOperations.cs | 2 +- .../DataFrameColumn.BinaryOperations.tt | 2 +- ...BinaryOperationImplementations.Exploded.cs | 156 +++++----- ...BinaryOperationImplementations.Exploded.tt | 2 +- ...imitiveDataFrameColumn.BinaryOperations.cs | 272 +++++------------- ...imitiveDataFrameColumn.BinaryOperations.tt | 67 ++--- 7 files changed, 167 insertions(+), 335 deletions(-) diff --git a/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude b/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude index c9a89655fd..7109530e3b 100644 --- a/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude +++ b/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude @@ -426,7 +426,6 @@ case MethodType.Unary: case MethodType.UnaryInPlace: throw new ArgumentException(); - return $"{dataFrameType}<{genericType}> {Op1Name}"; case MethodType.BinaryScalar: return $"{genericType} {Op2Name}"; case MethodType.ComparisonScalar: diff --git a/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.cs b/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.cs index 1c340575db..5ec875dbd4 100644 --- a/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.cs +++ b/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.cs @@ -332,4 +332,4 @@ public virtual PrimitiveDataFrameColumn ElementwiseIsNotNull() throw new NotImplementedException(); } } -} +} \ No newline at end of file diff --git a/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt b/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt index dc0c4fa988..7ffed4f62a 100644 --- a/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt +++ b/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt @@ -94,4 +94,4 @@ namespace Microsoft.Data.Analysis throw new NotImplementedException(); } } -} +} \ No newline at end of file diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs index 95e443545e..ac8035f0ba 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs @@ -1275,7 +1275,7 @@ public partial class BooleanDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(bool value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value)); } } @@ -1283,7 +1283,7 @@ public partial class ByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(byte value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value)); } } @@ -1291,7 +1291,7 @@ public partial class DecimalDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(decimal value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value)); } } @@ -1299,7 +1299,7 @@ public partial class DoubleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(double value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value)); } } @@ -1307,7 +1307,7 @@ public partial class SingleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(float value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value)); } } @@ -1315,7 +1315,7 @@ public partial class Int32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(int value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value)); } } @@ -1323,7 +1323,7 @@ public partial class Int64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(long value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value)); } } @@ -1331,7 +1331,7 @@ public partial class SByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(sbyte value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value)); } } @@ -1339,7 +1339,7 @@ public partial class Int16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(short value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value)); } } @@ -1347,7 +1347,7 @@ public partial class UInt32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(uint value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value)); } } @@ -1355,7 +1355,7 @@ public partial class UInt64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(ulong value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value)); } } @@ -1363,7 +1363,7 @@ public partial class UInt16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(ushort value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value)); } } @@ -1371,7 +1371,7 @@ public partial class DateTimeDataFrameColumn { internal BooleanDataFrameColumn ElementwiseEqualsImplementation(DateTime value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value)); } } @@ -1483,7 +1483,7 @@ public partial class BooleanDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(bool value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value)); } } @@ -1491,7 +1491,7 @@ public partial class ByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(byte value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value)); } } @@ -1499,7 +1499,7 @@ public partial class DecimalDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(decimal value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value)); } } @@ -1507,7 +1507,7 @@ public partial class DoubleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(double value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value)); } } @@ -1515,7 +1515,7 @@ public partial class SingleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(float value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value)); } } @@ -1523,7 +1523,7 @@ public partial class Int32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(int value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value)); } } @@ -1531,7 +1531,7 @@ public partial class Int64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(long value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value)); } } @@ -1539,7 +1539,7 @@ public partial class SByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(sbyte value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value)); } } @@ -1547,7 +1547,7 @@ public partial class Int16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(short value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value)); } } @@ -1555,7 +1555,7 @@ public partial class UInt32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(uint value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value)); } } @@ -1563,7 +1563,7 @@ public partial class UInt64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(ulong value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value)); } } @@ -1571,7 +1571,7 @@ public partial class UInt16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(ushort value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value)); } } @@ -1579,7 +1579,7 @@ public partial class DateTimeDataFrameColumn { internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(DateTime value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value)); } } @@ -1691,7 +1691,7 @@ public partial class BooleanDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(bool value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } @@ -1699,7 +1699,7 @@ public partial class ByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(byte value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } @@ -1707,7 +1707,7 @@ public partial class DecimalDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(decimal value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } @@ -1715,7 +1715,7 @@ public partial class DoubleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(double value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } @@ -1723,7 +1723,7 @@ public partial class SingleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(float value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } @@ -1731,7 +1731,7 @@ public partial class Int32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(int value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } @@ -1739,7 +1739,7 @@ public partial class Int64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(long value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } @@ -1747,7 +1747,7 @@ public partial class SByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(sbyte value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } @@ -1755,7 +1755,7 @@ public partial class Int16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(short value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } @@ -1763,7 +1763,7 @@ public partial class UInt32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(uint value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } @@ -1771,7 +1771,7 @@ public partial class UInt64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(ulong value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } @@ -1779,7 +1779,7 @@ public partial class UInt16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(ushort value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } @@ -1787,7 +1787,7 @@ public partial class DateTimeDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(DateTime value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value)); } } @@ -1899,7 +1899,7 @@ public partial class BooleanDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(bool value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } @@ -1907,7 +1907,7 @@ public partial class ByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(byte value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } @@ -1915,7 +1915,7 @@ public partial class DecimalDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(decimal value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } @@ -1923,7 +1923,7 @@ public partial class DoubleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(double value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } @@ -1931,7 +1931,7 @@ public partial class SingleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(float value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } @@ -1939,7 +1939,7 @@ public partial class Int32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(int value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } @@ -1947,7 +1947,7 @@ public partial class Int64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(long value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } @@ -1955,7 +1955,7 @@ public partial class SByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(sbyte value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } @@ -1963,7 +1963,7 @@ public partial class Int16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(short value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } @@ -1971,7 +1971,7 @@ public partial class UInt32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(uint value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } @@ -1979,7 +1979,7 @@ public partial class UInt64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(ulong value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } @@ -1987,7 +1987,7 @@ public partial class UInt16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(ushort value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } @@ -1995,7 +1995,7 @@ public partial class DateTimeDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(DateTime value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value)); } } @@ -2107,7 +2107,7 @@ public partial class BooleanDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(bool value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value)); } } @@ -2115,7 +2115,7 @@ public partial class ByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(byte value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value)); } } @@ -2123,7 +2123,7 @@ public partial class DecimalDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(decimal value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value)); } } @@ -2131,7 +2131,7 @@ public partial class DoubleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(double value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value)); } } @@ -2139,7 +2139,7 @@ public partial class SingleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(float value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value)); } } @@ -2147,7 +2147,7 @@ public partial class Int32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(int value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value)); } } @@ -2155,7 +2155,7 @@ public partial class Int64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(long value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value)); } } @@ -2163,7 +2163,7 @@ public partial class SByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(sbyte value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value)); } } @@ -2171,7 +2171,7 @@ public partial class Int16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(short value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value)); } } @@ -2179,7 +2179,7 @@ public partial class UInt32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(uint value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value)); } } @@ -2187,7 +2187,7 @@ public partial class UInt64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(ulong value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value)); } } @@ -2195,7 +2195,7 @@ public partial class UInt16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(ushort value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value)); } } @@ -2203,7 +2203,7 @@ public partial class DateTimeDataFrameColumn { internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(DateTime value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value)); } } @@ -2315,7 +2315,7 @@ public partial class BooleanDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(bool value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value)); } } @@ -2323,7 +2323,7 @@ public partial class ByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(byte value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value)); } } @@ -2331,7 +2331,7 @@ public partial class DecimalDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(decimal value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value)); } } @@ -2339,7 +2339,7 @@ public partial class DoubleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(double value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value)); } } @@ -2347,7 +2347,7 @@ public partial class SingleDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(float value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value)); } } @@ -2355,7 +2355,7 @@ public partial class Int32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(int value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value)); } } @@ -2363,7 +2363,7 @@ public partial class Int64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(long value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value)); } } @@ -2371,7 +2371,7 @@ public partial class SByteDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(sbyte value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value)); } } @@ -2379,7 +2379,7 @@ public partial class Int16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(short value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value)); } } @@ -2387,7 +2387,7 @@ public partial class UInt32DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(uint value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value)); } } @@ -2395,7 +2395,7 @@ public partial class UInt64DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(ulong value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value)); } } @@ -2403,7 +2403,7 @@ public partial class UInt16DataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(ushort value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value)); } } @@ -2411,7 +2411,7 @@ public partial class DateTimeDataFrameColumn { internal BooleanDataFrameColumn ElementwiseLessThanImplementation(DateTime value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value)); } } } diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt index b71ba41c3b..001aab32b1 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt @@ -201,7 +201,7 @@ void GenerateAllComparisonScalarCombinationsForMethod(string inputMethodName) { internal <#=fullReturnType#> <#=methodName#>(<#=otherColumnType#> value) { - return new BooleanDataFrameColumn (Name, ColumnContainer.<#=inputMethodName#>(value)); + return new BooleanDataFrameColumn(Name, ColumnContainer.<#=inputMethodName#>(value)); } } <# diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs index 74506e0904..461badeda3 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs @@ -1862,9 +1862,7 @@ internal PrimitiveDataFrameColumn ElementwiseEqualsImplementation(Primi { throw new NotSupportedException(); } - PrimitiveDataFrameColumn retboolColumn = CloneAsBooleanColumn(); - (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseEquals(column._columnContainer, retboolColumn._columnContainer); - return retboolColumn; + return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseEquals(column._columnContainer)); case Type decimalType when decimalType == typeof(decimal): if (typeof(U) == typeof(bool)) { @@ -1874,25 +1872,19 @@ internal PrimitiveDataFrameColumn ElementwiseEqualsImplementation(Primi { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseEquals(column._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(column._columnContainer)); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseEquals(column.CloneAsDecimalColumn()._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseEquals(column.CloneAsDecimalColumn()._columnContainer)); } case Type DateTimeType when DateTimeType == typeof(DateTime): if (typeof(U) != typeof(DateTime)) { throw new NotSupportedException(); } - PrimitiveDataFrameColumn retDateTimeColumn = CloneAsBooleanColumn(); - (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseEquals(column._columnContainer, retDateTimeColumn._columnContainer); - return retDateTimeColumn; + return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseEquals(column._columnContainer)); case Type byteType when byteType == typeof(byte): case Type charType when charType == typeof(char): case Type doubleType when doubleType == typeof(double): @@ -1912,25 +1904,19 @@ internal PrimitiveDataFrameColumn ElementwiseEqualsImplementation(Primi { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseEquals(column._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(column._columnContainer)); } else { if (typeof(U) == typeof(decimal)) { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseEquals((column as PrimitiveDataFrameColumn)._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseEquals((column as PrimitiveDataFrameColumn)._columnContainer)); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn doubleColumn = CloneAsDoubleColumn(); - doubleColumn._columnContainer.ElementwiseEquals(column.CloneAsDoubleColumn()._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseEquals(column.CloneAsDoubleColumn()._columnContainer)); } } default: @@ -1947,9 +1933,7 @@ internal PrimitiveDataFrameColumn ElementwiseEqualsImplementation(U val { throw new NotSupportedException(); } - PrimitiveDataFrameColumn retboolColumn = CloneAsBooleanColumn(); - (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseEquals(Unsafe.As(ref value), retboolColumn._columnContainer); - return retboolColumn; + return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseEquals(Unsafe.As(ref value))); case Type decimalType when decimalType == typeof(decimal): if (typeof(U) == typeof(bool)) { @@ -1959,25 +1943,19 @@ internal PrimitiveDataFrameColumn ElementwiseEqualsImplementation(U val { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseEquals(Unsafe.As(ref value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(Unsafe.As(ref value))); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseEquals(DecimalConverter.Instance.GetDecimal(value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseEquals(DecimalConverter.Instance.GetDecimal(value))); } case Type DateTimeType when DateTimeType == typeof(DateTime): if (typeof(U) != typeof(DateTime)) { throw new NotSupportedException(); } - PrimitiveDataFrameColumn retDateTimeColumn = CloneAsBooleanColumn(); - (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseEquals(Unsafe.As(ref value), retDateTimeColumn._columnContainer); - return retDateTimeColumn; + return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseEquals(Unsafe.As(ref value))); case Type byteType when byteType == typeof(byte): case Type charType when charType == typeof(char): case Type doubleType when doubleType == typeof(double): @@ -1997,25 +1975,19 @@ internal PrimitiveDataFrameColumn ElementwiseEqualsImplementation(U val { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseEquals(Unsafe.As(ref value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(Unsafe.As(ref value))); } else { if (typeof(U) == typeof(decimal)) { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseEquals(DecimalConverter.Instance.GetDecimal(value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseEquals(DecimalConverter.Instance.GetDecimal(value))); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn doubleColumn = CloneAsDoubleColumn(); - doubleColumn._columnContainer.ElementwiseEquals(DoubleConverter.Instance.GetDouble(value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseEquals(DoubleConverter.Instance.GetDouble(value))); } } default: @@ -2037,9 +2009,7 @@ internal PrimitiveDataFrameColumn ElementwiseNotEqualsImplementation(Pr { throw new NotSupportedException(); } - PrimitiveDataFrameColumn retboolColumn = CloneAsBooleanColumn(); - (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseNotEquals(column._columnContainer, retboolColumn._columnContainer); - return retboolColumn; + return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseNotEquals(column._columnContainer)); case Type decimalType when decimalType == typeof(decimal): if (typeof(U) == typeof(bool)) { @@ -2049,25 +2019,19 @@ internal PrimitiveDataFrameColumn ElementwiseNotEqualsImplementation(Pr { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseNotEquals(column._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(column._columnContainer)); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseNotEquals(column.CloneAsDecimalColumn()._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseNotEquals(column.CloneAsDecimalColumn()._columnContainer)); } case Type DateTimeType when DateTimeType == typeof(DateTime): if (typeof(U) != typeof(DateTime)) { throw new NotSupportedException(); } - PrimitiveDataFrameColumn retDateTimeColumn = CloneAsBooleanColumn(); - (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseNotEquals(column._columnContainer, retDateTimeColumn._columnContainer); - return retDateTimeColumn; + return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseNotEquals(column._columnContainer)); case Type byteType when byteType == typeof(byte): case Type charType when charType == typeof(char): case Type doubleType when doubleType == typeof(double): @@ -2087,25 +2051,19 @@ internal PrimitiveDataFrameColumn ElementwiseNotEqualsImplementation(Pr { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseNotEquals(column._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(column._columnContainer)); } else { if (typeof(U) == typeof(decimal)) { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseNotEquals((column as PrimitiveDataFrameColumn)._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseNotEquals((column as PrimitiveDataFrameColumn)._columnContainer)); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn doubleColumn = CloneAsDoubleColumn(); - doubleColumn._columnContainer.ElementwiseNotEquals(column.CloneAsDoubleColumn()._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseNotEquals(column.CloneAsDoubleColumn()._columnContainer)); } } default: @@ -2122,9 +2080,7 @@ internal PrimitiveDataFrameColumn ElementwiseNotEqualsImplementation(U { throw new NotSupportedException(); } - PrimitiveDataFrameColumn retboolColumn = CloneAsBooleanColumn(); - (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseNotEquals(Unsafe.As(ref value), retboolColumn._columnContainer); - return retboolColumn; + return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseNotEquals(Unsafe.As(ref value))); case Type decimalType when decimalType == typeof(decimal): if (typeof(U) == typeof(bool)) { @@ -2134,25 +2090,19 @@ internal PrimitiveDataFrameColumn ElementwiseNotEqualsImplementation(U { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseNotEquals(Unsafe.As(ref value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(Unsafe.As(ref value))); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseNotEquals(DecimalConverter.Instance.GetDecimal(value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseNotEquals(DecimalConverter.Instance.GetDecimal(value))); } case Type DateTimeType when DateTimeType == typeof(DateTime): if (typeof(U) != typeof(DateTime)) { throw new NotSupportedException(); } - PrimitiveDataFrameColumn retDateTimeColumn = CloneAsBooleanColumn(); - (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseNotEquals(Unsafe.As(ref value), retDateTimeColumn._columnContainer); - return retDateTimeColumn; + return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseNotEquals(Unsafe.As(ref value))); case Type byteType when byteType == typeof(byte): case Type charType when charType == typeof(char): case Type doubleType when doubleType == typeof(double): @@ -2172,25 +2122,19 @@ internal PrimitiveDataFrameColumn ElementwiseNotEqualsImplementation(U { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseNotEquals(Unsafe.As(ref value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(Unsafe.As(ref value))); } else { if (typeof(U) == typeof(decimal)) { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseNotEquals(DecimalConverter.Instance.GetDecimal(value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseNotEquals(DecimalConverter.Instance.GetDecimal(value))); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn doubleColumn = CloneAsDoubleColumn(); - doubleColumn._columnContainer.ElementwiseNotEquals(DoubleConverter.Instance.GetDouble(value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseNotEquals(DoubleConverter.Instance.GetDouble(value))); } } default: @@ -2218,16 +2162,12 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanOrEqualImplementat { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(column._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(column._columnContainer)); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(column.CloneAsDecimalColumn()._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(column.CloneAsDecimalColumn()._columnContainer)); } case Type DateTimeType when DateTimeType == typeof(DateTime): throw new NotSupportedException(); @@ -2250,25 +2190,19 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanOrEqualImplementat { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(column._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(column._columnContainer)); } else { if (typeof(U) == typeof(decimal)) { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual((column as PrimitiveDataFrameColumn)._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual((column as PrimitiveDataFrameColumn)._columnContainer)); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn doubleColumn = CloneAsDoubleColumn(); - doubleColumn._columnContainer.ElementwiseGreaterThanOrEqual(column.CloneAsDoubleColumn()._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThanOrEqual(column.CloneAsDoubleColumn()._columnContainer)); } } default: @@ -2291,16 +2225,12 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanOrEqualImplementat { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(Unsafe.As(ref value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(Unsafe.As(ref value))); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(DecimalConverter.Instance.GetDecimal(value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(DecimalConverter.Instance.GetDecimal(value))); } case Type DateTimeType when DateTimeType == typeof(DateTime): throw new NotSupportedException(); @@ -2323,25 +2253,19 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanOrEqualImplementat { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(Unsafe.As(ref value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(Unsafe.As(ref value))); } else { if (typeof(U) == typeof(decimal)) { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(DecimalConverter.Instance.GetDecimal(value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(DecimalConverter.Instance.GetDecimal(value))); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn doubleColumn = CloneAsDoubleColumn(); - doubleColumn._columnContainer.ElementwiseGreaterThanOrEqual(DoubleConverter.Instance.GetDouble(value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThanOrEqual(DoubleConverter.Instance.GetDouble(value))); } } default: @@ -2369,16 +2293,12 @@ internal PrimitiveDataFrameColumn ElementwiseLessThanOrEqualImplementation { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(column._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(column._columnContainer)); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseLessThanOrEqual(column.CloneAsDecimalColumn()._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual(column.CloneAsDecimalColumn()._columnContainer)); } case Type DateTimeType when DateTimeType == typeof(DateTime): throw new NotSupportedException(); @@ -2401,25 +2321,19 @@ internal PrimitiveDataFrameColumn ElementwiseLessThanOrEqualImplementation { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(column._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(column._columnContainer)); } else { if (typeof(U) == typeof(decimal)) { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseLessThanOrEqual((column as PrimitiveDataFrameColumn)._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual((column as PrimitiveDataFrameColumn)._columnContainer)); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn doubleColumn = CloneAsDoubleColumn(); - doubleColumn._columnContainer.ElementwiseLessThanOrEqual(column.CloneAsDoubleColumn()._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThanOrEqual(column.CloneAsDoubleColumn()._columnContainer)); } } default: @@ -2442,16 +2356,12 @@ internal PrimitiveDataFrameColumn ElementwiseLessThanOrEqualImplementation { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(Unsafe.As(ref value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(Unsafe.As(ref value))); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseLessThanOrEqual(DecimalConverter.Instance.GetDecimal(value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual(DecimalConverter.Instance.GetDecimal(value))); } case Type DateTimeType when DateTimeType == typeof(DateTime): throw new NotSupportedException(); @@ -2474,25 +2384,19 @@ internal PrimitiveDataFrameColumn ElementwiseLessThanOrEqualImplementation { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(Unsafe.As(ref value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(Unsafe.As(ref value))); } else { if (typeof(U) == typeof(decimal)) { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseLessThanOrEqual(DecimalConverter.Instance.GetDecimal(value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual(DecimalConverter.Instance.GetDecimal(value))); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn doubleColumn = CloneAsDoubleColumn(); - doubleColumn._columnContainer.ElementwiseLessThanOrEqual(DoubleConverter.Instance.GetDouble(value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThanOrEqual(DoubleConverter.Instance.GetDouble(value))); } } default: @@ -2520,16 +2424,12 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanImplementation( { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseGreaterThan(column._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(column._columnContainer)); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseGreaterThan(column.CloneAsDecimalColumn()._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan(column.CloneAsDecimalColumn()._columnContainer)); } case Type DateTimeType when DateTimeType == typeof(DateTime): throw new NotSupportedException(); @@ -2552,25 +2452,19 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanImplementation( { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseGreaterThan(column._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(column._columnContainer)); } else { if (typeof(U) == typeof(decimal)) { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseGreaterThan((column as PrimitiveDataFrameColumn)._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan((column as PrimitiveDataFrameColumn)._columnContainer)); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn doubleColumn = CloneAsDoubleColumn(); - doubleColumn._columnContainer.ElementwiseGreaterThan(column.CloneAsDoubleColumn()._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThan(column.CloneAsDoubleColumn()._columnContainer)); } } default: @@ -2593,16 +2487,12 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanImplementation( { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseGreaterThan(Unsafe.As(ref value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(Unsafe.As(ref value))); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseGreaterThan(DecimalConverter.Instance.GetDecimal(value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan(DecimalConverter.Instance.GetDecimal(value))); } case Type DateTimeType when DateTimeType == typeof(DateTime): throw new NotSupportedException(); @@ -2625,25 +2515,19 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanImplementation( { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseGreaterThan(Unsafe.As(ref value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(Unsafe.As(ref value))); } else { if (typeof(U) == typeof(decimal)) { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseGreaterThan(DecimalConverter.Instance.GetDecimal(value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan(DecimalConverter.Instance.GetDecimal(value))); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn doubleColumn = CloneAsDoubleColumn(); - doubleColumn._columnContainer.ElementwiseGreaterThan(DoubleConverter.Instance.GetDouble(value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThan(DoubleConverter.Instance.GetDouble(value))); } } default: @@ -2671,16 +2555,12 @@ internal PrimitiveDataFrameColumn ElementwiseLessThanImplementation(Pri { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseLessThan(column._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(column._columnContainer)); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseLessThan(column.CloneAsDecimalColumn()._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan(column.CloneAsDecimalColumn()._columnContainer)); } case Type DateTimeType when DateTimeType == typeof(DateTime): throw new NotSupportedException(); @@ -2703,25 +2583,19 @@ internal PrimitiveDataFrameColumn ElementwiseLessThanImplementation(Pri { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseLessThan(column._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(column._columnContainer)); } else { if (typeof(U) == typeof(decimal)) { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseLessThan((column as PrimitiveDataFrameColumn)._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan((column as PrimitiveDataFrameColumn)._columnContainer)); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn doubleColumn = CloneAsDoubleColumn(); - doubleColumn._columnContainer.ElementwiseLessThan(column.CloneAsDoubleColumn()._columnContainer, newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThan(column.CloneAsDoubleColumn()._columnContainer)); } } default: @@ -2744,16 +2618,12 @@ internal PrimitiveDataFrameColumn ElementwiseLessThanImplementation(U v { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseLessThan(Unsafe.As(ref value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(Unsafe.As(ref value))); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseLessThan(DecimalConverter.Instance.GetDecimal(value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan(DecimalConverter.Instance.GetDecimal(value))); } case Type DateTimeType when DateTimeType == typeof(DateTime): throw new NotSupportedException(); @@ -2776,25 +2646,19 @@ internal PrimitiveDataFrameColumn ElementwiseLessThanImplementation(U v { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.ElementwiseLessThan(Unsafe.As(ref value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(Unsafe.As(ref value))); } else { if (typeof(U) == typeof(decimal)) { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.ElementwiseLessThan(DecimalConverter.Instance.GetDecimal(value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan(DecimalConverter.Instance.GetDecimal(value))); } else { - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); PrimitiveDataFrameColumn doubleColumn = CloneAsDoubleColumn(); - doubleColumn._columnContainer.ElementwiseLessThan(DoubleConverter.Instance.GetDouble(value), newColumn._columnContainer); - return newColumn; + return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThan(DoubleConverter.Instance.GetDouble(value))); } } default: diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt index 83a6c80d49..66d04d02ec 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt @@ -189,13 +189,10 @@ namespace Microsoft.Data.Analysis { throw new NotSupportedException(); } -<# if (method.MethodType == MethodType.ComparisonScalar || method.MethodType == MethodType.Comparison) { #> - PrimitiveDataFrameColumn ret<#=type.TypeName#>Column = CloneAsBooleanColumn(); <# if (method.MethodType == MethodType.ComparisonScalar) { #> - (this as PrimitiveDataFrameColumn)._columnContainer.<#=method.MethodName#>(Unsafe.As(ref value), ret<#=type.TypeName#>Column._columnContainer); -<# } else { #> - (this as PrimitiveDataFrameColumn)._columnContainer.<#=method.MethodName#>(column._columnContainer, ret<#=type.TypeName#>Column._columnContainer); -<# } #> + return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.<#=method.MethodName#>(Unsafe.As(ref value))); +<# } else if (method.MethodType == MethodType.Comparison) { #> + return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.<#=method.MethodName#>(column._columnContainer)); <# } else if (method.MethodType == MethodType.BinaryScalar) {#> PrimitiveDataFrameColumn column = this as PrimitiveDataFrameColumn; PrimitiveDataFrameColumn ret<#=type.TypeName#>Column = <#=GenerateInPlaceStatement("column", "column.Clone()")#>; @@ -205,7 +202,6 @@ namespace Microsoft.Data.Analysis PrimitiveDataFrameColumn ret<#=type.TypeName#>Column = <#=GenerateInPlaceStatement("column", "column.Clone()")#>; ret<#=type.TypeName#>Column._columnContainer.<#=method.MethodName#>(column._columnContainer); <# } #> - return ret<#=type.TypeName#>Column; <# } #> <# } else if (type.TypeName == "decimal") { #> case Type <#=type.TypeName#>Type when <#=type.TypeName#>Type == typeof(<#=type.TypeName#>): @@ -216,18 +212,12 @@ namespace Microsoft.Data.Analysis if (typeof(U) == typeof(T)) { // No conversions -<# if (method.MethodType == MethodType.ComparisonScalar || method.MethodType == MethodType.Comparison) { #> <# if (method.MethodType == MethodType.ComparisonScalar) { #> PrimitiveDataFrameColumn primitiveColumn = this; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.<#=method.MethodName#>(Unsafe.As(ref value), newColumn._columnContainer); - return newColumn; -<# } else { #> + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.<#=method.MethodName#>(Unsafe.As(ref value))); +<# } else if (method.MethodType == MethodType.Comparison){ #> PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.<#=method.MethodName#>(column._columnContainer, newColumn._columnContainer); - return newColumn; -<# } #> + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.<#=method.MethodName#>(column._columnContainer)); <# } else if (method.IsBitwise == true ) { #> throw new NotSupportedException(); <# } else if (method.MethodType == MethodType.BinaryScalar ) { #> @@ -255,17 +245,12 @@ namespace Microsoft.Data.Analysis throw new ArgumentException(string.Format(Strings.MismatchedColumnValueType, typeof(T)), nameof(column)); } <# } #> -<# if (method.MethodType == MethodType.ComparisonScalar || method.MethodType == MethodType.Comparison) { #> - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); <# if (method.MethodType == MethodType.ComparisonScalar) { #> PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.<#=method.MethodName#>(DecimalConverter.Instance.GetDecimal(value), newColumn._columnContainer); - return newColumn; -<# } else { #> + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.<#=method.MethodName#>(DecimalConverter.Instance.GetDecimal(value))); +<# } else if (method.MethodType == MethodType.Comparison){ #> PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.<#=method.MethodName#>(column.CloneAsDecimalColumn()._columnContainer, newColumn._columnContainer); - return newColumn; -<# } #> + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.<#=method.MethodName#>(column.CloneAsDecimalColumn()._columnContainer)); <# } else if (method.IsBitwise == true) { #> throw new NotSupportedException(); <# } else if (method.MethodType == MethodType.BinaryScalar) { #> @@ -299,18 +284,12 @@ namespace Microsoft.Data.Analysis if (typeof(U) == typeof(T)) { // No conversions -<# if (method.MethodType == MethodType.ComparisonScalar || method.MethodType == MethodType.Comparison) { #> <# if (method.MethodType == MethodType.ComparisonScalar) { #> PrimitiveDataFrameColumn primitiveColumn = this; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.<#=method.MethodName#>(Unsafe.As(ref value), newColumn._columnContainer); - return newColumn; -<# } else { #> + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.<#=method.MethodName#>(Unsafe.As(ref value))); +<# } else if (method.MethodType == MethodType.Comparison) { #> PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); - primitiveColumn._columnContainer.<#=method.MethodName#>(column._columnContainer, newColumn._columnContainer); - return newColumn; -<# } #> + return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.<#=method.MethodName#>(column._columnContainer)); <# } else if (method.IsBitwise == true ) { #> throw new NotSupportedException(); <# } else if (method.MethodType == MethodType.BinaryScalar ) { #> @@ -340,17 +319,12 @@ namespace Microsoft.Data.Analysis <# } #> if (typeof(U) == typeof(decimal)) { -<# if (method.MethodType == MethodType.ComparisonScalar || method.MethodType == MethodType.Comparison) { #> - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); <# if (method.MethodType == MethodType.ComparisonScalar) { #> PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.<#=method.MethodName#>(DecimalConverter.Instance.GetDecimal(value), newColumn._columnContainer); - return newColumn; -<# } else { #> + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.<#=method.MethodName#>(DecimalConverter.Instance.GetDecimal(value))); +<# } else if (method.MethodType == MethodType.Comparison) { #> PrimitiveDataFrameColumn decimalColumn = CloneAsDecimalColumn(); - decimalColumn._columnContainer.<#=method.MethodName#>((column as PrimitiveDataFrameColumn)._columnContainer, newColumn._columnContainer); - return newColumn; -<# } #> + return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.<#=method.MethodName#>((column as PrimitiveDataFrameColumn)._columnContainer)); <# } else if (method.IsBitwise == true) { #> throw new NotSupportedException(); <# } else if (method.MethodType == MethodType.BinaryScalar) { #> @@ -365,17 +339,12 @@ namespace Microsoft.Data.Analysis } else { -<# if (method.MethodType == MethodType.ComparisonScalar || method.MethodType == MethodType.Comparison) { #> - PrimitiveDataFrameColumn newColumn = CloneAsBooleanColumn(); <# if (method.MethodType == MethodType.ComparisonScalar) { #> PrimitiveDataFrameColumn doubleColumn = CloneAsDoubleColumn(); - doubleColumn._columnContainer.<#=method.MethodName#>(DoubleConverter.Instance.GetDouble(value), newColumn._columnContainer); - return newColumn; -<# } else { #> + return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.<#=method.MethodName#>(DoubleConverter.Instance.GetDouble(value))); +<# } else if (method.MethodType == MethodType.Comparison) { #> PrimitiveDataFrameColumn doubleColumn = CloneAsDoubleColumn(); - doubleColumn._columnContainer.<#=method.MethodName#>(column.CloneAsDoubleColumn()._columnContainer, newColumn._columnContainer); - return newColumn; -<# } #> + return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.<#=method.MethodName#>(column.CloneAsDoubleColumn()._columnContainer)); <# } else if (method.IsBitwise == true) { #> throw new NotSupportedException(); <# } else if (method.MethodType == MethodType.BinaryScalar ) { #> From 1640b5952bb5a4581949376c624436608df3414e Mon Sep 17 00:00:00 2001 From: Aleksei Smirnov Date: Thu, 13 Jul 2023 18:12:44 +0300 Subject: [PATCH 15/18] Fix unit tests --- .../ColumnArithmeticTemplate.ttinclude | 1 - .../PrimitiveDataFrameColumnArithmetic.cs | 304 +++++++++--------- .../PrimitiveDataFrameColumnArithmetic.tt | 8 +- 3 files changed, 158 insertions(+), 155 deletions(-) diff --git a/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude b/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude index 7109530e3b..dbe44c3889 100644 --- a/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude +++ b/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude @@ -438,7 +438,6 @@ return $"{dataFrameType}<{genericType}> {Op2Name}"; case MethodType.Contraction: throw new ArgumentException(); - return $"{dataFrameType}<{genericType}> {Op1Name}, {dataFrameType}<{genericType}> {Op2Name}, int[] leftAxes, int[] rightAxes"; default: throw new ArgumentException(); } diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs index 8c976fbcaf..89143a8316 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs @@ -333,7 +333,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -349,7 +349,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, bool scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -364,7 +364,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -380,7 +380,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, bool scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -784,7 +784,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -800,7 +800,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, byte scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -815,7 +815,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -831,7 +831,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, byte scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -846,7 +846,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -862,7 +862,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, byte scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -877,7 +877,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -893,7 +893,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, byte scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -908,7 +908,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -924,7 +924,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, byte scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -939,7 +939,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -955,7 +955,7 @@ public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContain public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, byte scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1319,7 +1319,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1335,7 +1335,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, char scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1350,7 +1350,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1366,7 +1366,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, char scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1381,7 +1381,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1397,7 +1397,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, char scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1412,7 +1412,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1428,7 +1428,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, char scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1443,7 +1443,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1459,7 +1459,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, char scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1474,7 +1474,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1490,7 +1490,7 @@ public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContain public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, char scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1763,7 +1763,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1779,7 +1779,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, decimal scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1794,7 +1794,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1810,7 +1810,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, decimal scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1825,7 +1825,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1841,7 +1841,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, decimal scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1856,7 +1856,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1872,7 +1872,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, decimal scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1887,7 +1887,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1903,7 +1903,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, decimal scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -1918,7 +1918,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -1934,7 +1934,7 @@ public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContain public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, decimal scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2207,7 +2207,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2223,7 +2223,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, double scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2238,7 +2238,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2254,7 +2254,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, double scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2269,7 +2269,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2285,7 +2285,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, double scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2300,7 +2300,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2316,7 +2316,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, double scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2331,7 +2331,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2347,7 +2347,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, double scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2362,7 +2362,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2378,7 +2378,7 @@ public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContain public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, double scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2651,7 +2651,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2667,7 +2667,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, float scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2682,7 +2682,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2698,7 +2698,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, float scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2713,7 +2713,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2729,7 +2729,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, float scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2744,7 +2744,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2760,7 +2760,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, float scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2775,7 +2775,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2791,7 +2791,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, float scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -2806,7 +2806,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -2822,7 +2822,7 @@ public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContain public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, float scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3186,7 +3186,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3202,7 +3202,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, int scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3217,7 +3217,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3233,7 +3233,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, int scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3248,7 +3248,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3264,7 +3264,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, int scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3279,7 +3279,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3295,7 +3295,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, int scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3310,7 +3310,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3326,7 +3326,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, int scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3341,7 +3341,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3357,7 +3357,7 @@ public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContain public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, int scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3721,7 +3721,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3737,7 +3737,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, long scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3752,7 +3752,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3768,7 +3768,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, long scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3783,7 +3783,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3799,7 +3799,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, long scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3814,7 +3814,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3830,7 +3830,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, long scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3845,7 +3845,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3861,7 +3861,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, long scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -3876,7 +3876,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -3892,7 +3892,7 @@ public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContain public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, long scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4256,7 +4256,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4272,7 +4272,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, sbyte scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4287,7 +4287,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4303,7 +4303,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, sbyte scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4318,7 +4318,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4334,7 +4334,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, sbyte scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4349,7 +4349,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4365,7 +4365,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, sbyte scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4380,7 +4380,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4396,7 +4396,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, sbyte scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4411,7 +4411,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4427,7 +4427,7 @@ public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContain public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, sbyte scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4791,7 +4791,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4807,7 +4807,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, short scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4822,7 +4822,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4838,7 +4838,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, short scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4853,7 +4853,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4869,7 +4869,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, short scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4884,7 +4884,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4900,7 +4900,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, short scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4915,7 +4915,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4931,7 +4931,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, short scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -4946,7 +4946,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -4962,7 +4962,7 @@ public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContain public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, short scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5326,7 +5326,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5342,7 +5342,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, uint scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5357,7 +5357,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5373,7 +5373,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, uint scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5388,7 +5388,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5404,7 +5404,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, uint scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5419,7 +5419,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5435,7 +5435,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, uint scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5450,7 +5450,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5466,7 +5466,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, uint scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5481,7 +5481,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5497,7 +5497,7 @@ public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContain public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, uint scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5861,7 +5861,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5877,7 +5877,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, ulong scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5892,7 +5892,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5908,7 +5908,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, ulong scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5923,7 +5923,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5939,7 +5939,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, ulong scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5954,7 +5954,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -5970,7 +5970,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ulong scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -5985,7 +5985,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -6001,7 +6001,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, ulong scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -6016,7 +6016,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -6032,7 +6032,7 @@ public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContain public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, ulong scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -6396,7 +6396,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -6412,7 +6412,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, ushort scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -6427,7 +6427,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -6443,7 +6443,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, ushort scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -6458,7 +6458,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -6474,7 +6474,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, ushort scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -6489,7 +6489,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveCol public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -6505,7 +6505,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ushort scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -6520,7 +6520,7 @@ public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumn public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -6536,7 +6536,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, ushort scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -6551,7 +6551,7 @@ public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnCont public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -6567,7 +6567,7 @@ public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContain public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, ushort scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -6715,7 +6715,7 @@ public void RightShift(PrimitiveColumnContainer column, int value) public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -6731,7 +6731,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, DateTime scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { @@ -6746,7 +6746,7 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); long index = 0; for (int b = 0; b < left.Buffers.Count; b++) { @@ -6762,7 +6762,7 @@ public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContai public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, DateTime scalar) { - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; for (int b = 0; b < column.Buffers.Count; b++) { diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt index d158295b1a..9ad6e313ee 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt @@ -68,8 +68,12 @@ namespace Microsoft.Data.Analysis <# if ((method.IsNumeric && !type.SupportsNumeric) || (method.IsBitwise && !type.SupportsBitwise) || (type.UnsupportedMethods.Contains(method.MethodName))) { #> throw new NotSupportedException(); <# } else if (method.Operator != null) { #> -<# if (method.MethodType == MethodType.Comparison || method.MethodType == MethodType.ComparisonScalar) { #> - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(); +<# if (method.MethodType == MethodType.Comparison) { #> + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); + long index = 0; +<# } #> +<# if (method.MethodType == MethodType.ComparisonScalar) { #> + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); long index = 0; <# } #> for (int b = 0; b < <#= method.Op1Name #>.Buffers.Count; b++) From 942716935bf319847a189a6f05d3b7460cce98d2 Mon Sep 17 00:00:00 2001 From: Aleksei Smirnov Date: Thu, 13 Jul 2023 19:04:21 +0300 Subject: [PATCH 16/18] Fix spaces --- ...imitiveColumnContainer.BinaryOperations.cs | 20 +++++++++++++++++++ ...imitiveColumnContainer.BinaryOperations.tt | 3 ++- 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs index a17c888f36..ca16f01489 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs @@ -10,6 +10,7 @@ namespace Microsoft.Data.Analysis internal partial class PrimitiveColumnContainer where T : unmanaged { + public PrimitiveColumnContainer Add(PrimitiveColumnContainer right) { PrimitiveDataFrameColumnArithmetic.Instance.Add(this, right); @@ -122,85 +123,104 @@ public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseEquals(this, right); } + public PrimitiveColumnContainer ElementwiseEquals(T scalar) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseEquals(this, scalar); } + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer right) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseNotEquals(this, right); } + public PrimitiveColumnContainer ElementwiseNotEquals(T scalar) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseNotEquals(this, scalar); } + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer right) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseGreaterThanOrEqual(this, right); } + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(T scalar) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseGreaterThanOrEqual(this, scalar); } + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer right) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseLessThanOrEqual(this, right); } + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(T scalar) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseLessThanOrEqual(this, scalar); } + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer right) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseGreaterThan(this, right); } + public PrimitiveColumnContainer ElementwiseGreaterThan(T scalar) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseGreaterThan(this, scalar); } + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer right) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseLessThan(this, right); } + public PrimitiveColumnContainer ElementwiseLessThan(T scalar) { return PrimitiveDataFrameColumnArithmetic.Instance.ElementwiseLessThan(this, scalar); } + public PrimitiveColumnContainer ReverseAdd(T scalar) { PrimitiveDataFrameColumnArithmetic.Instance.Add(scalar, this); return this; } + public PrimitiveColumnContainer ReverseSubtract(T scalar) { PrimitiveDataFrameColumnArithmetic.Instance.Subtract(scalar, this); return this; } + public PrimitiveColumnContainer ReverseMultiply(T scalar) { PrimitiveDataFrameColumnArithmetic.Instance.Multiply(scalar, this); return this; } + public PrimitiveColumnContainer ReverseDivide(T scalar) { PrimitiveDataFrameColumnArithmetic.Instance.Divide(scalar, this); return this; } + public PrimitiveColumnContainer ReverseModulo(T scalar) { PrimitiveDataFrameColumnArithmetic.Instance.Modulo(scalar, this); return this; } + public PrimitiveColumnContainer ReverseAnd(T scalar) { PrimitiveDataFrameColumnArithmetic.Instance.And(scalar, this); return this; } + public PrimitiveColumnContainer ReverseOr(T scalar) { PrimitiveDataFrameColumnArithmetic.Instance.Or(scalar, this); return this; } + public PrimitiveColumnContainer ReverseXor(T scalar) { PrimitiveDataFrameColumnArithmetic.Instance.Xor(scalar, this); diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt index 9bdd5c9c85..4af33da261 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt +++ b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt @@ -17,6 +17,7 @@ namespace Microsoft.Data.Analysis where T : unmanaged { <# foreach (MethodConfiguration method in methodConfiguration) { #> + <# if (method.MethodType == MethodType.Comparison) { #> public PrimitiveColumnContainer <#=method.MethodName#>(PrimitiveColumnContainer right) { @@ -39,11 +40,11 @@ namespace Microsoft.Data.Analysis <# } #> return this; } - <# } #> <# } #> <# foreach (MethodConfiguration method in methodConfiguration) { #> <# if (method.MethodType == MethodType.BinaryScalar) { #> + public PrimitiveColumnContainer Reverse<#=method.MethodName#>(T scalar) { PrimitiveDataFrameColumnArithmetic.Instance.<#=method.MethodName#>(scalar, this); From 80b4770ff78e30769bba23a4fb3d149560a5851c Mon Sep 17 00:00:00 2001 From: Aleksei Smirnov Date: Thu, 13 Jul 2023 22:24:54 +0300 Subject: [PATCH 17/18] Fix merge issues --- src/Microsoft.Data.Analysis/DataFrame.IO.cs | 2 +- .../PrimitiveDataFrameColumnArithmetic.cs | 43 ---- .../PrimitiveDataFrameColumnComputations.cs | 240 ------------------ .../DataFrame.IOTests.cs | 2 +- .../DataFrameTests.cs | 14 - 5 files changed, 2 insertions(+), 299 deletions(-) diff --git a/src/Microsoft.Data.Analysis/DataFrame.IO.cs b/src/Microsoft.Data.Analysis/DataFrame.IO.cs index e30b33401d..569e5f47ae 100644 --- a/src/Microsoft.Data.Analysis/DataFrame.IO.cs +++ b/src/Microsoft.Data.Analysis/DataFrame.IO.cs @@ -332,7 +332,7 @@ private static DataFrameColumn CreateColumn(Type kind, string columnName) } else if (kind == typeof(DateTime)) { - ret = new DateTimeDataFrameColumn(columnName); + ret = new PrimitiveDataFrameColumn(columnName); } else { diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs index ef1064327e..7fc3fa521e 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs @@ -347,49 +347,6 @@ public void ElementwiseLessThan(PrimitiveColumnContainer column, bool scal } } - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; - long index = 0; internal class DateTimeArithmetic : IPrimitiveDataFrameColumnArithmetic { public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer right) diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.cs index 2139b98b2c..4105cb0c9c 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.cs @@ -240,246 +240,6 @@ public void Round(PrimitiveColumnContainer column) } public PrimitiveColumnContainer CreateTruncating(PrimitiveColumnContainer column) where U : unmanaged, INumber - bool hasValue = false; - value = (byte)(Math.Max(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (byte)(Math.Min(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - - ret = value; - var hasValue = false; - value = (byte)(readOnlySpan[i] + value); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (char)(Math.Max(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (char)(Math.Min(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - - ret = value; - var hasValue = false; - value = (char)(readOnlySpan[i] + value); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (decimal)(Math.Max(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (decimal)(Math.Min(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - - ret = value; - var hasValue = false; - value = (decimal)(readOnlySpan[i] + value); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (double)(Math.Max(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (double)(Math.Min(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - - ret = value; - var hasValue = false; - value = (double)(readOnlySpan[i] + value); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (float)(Math.Max(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (float)(Math.Min(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - - ret = value; - var hasValue = false; - value = (float)(readOnlySpan[i] + value); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (int)(Math.Max(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (int)(Math.Min(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - - ret = value; - var hasValue = false; - value = (int)(readOnlySpan[i] + value); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (long)(Math.Max(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (long)(Math.Min(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - - ret = value; - var hasValue = false; - value = (long)(readOnlySpan[i] + value); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (sbyte)(Math.Max(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (sbyte)(Math.Min(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - - ret = value; - var hasValue = false; - value = (sbyte)(readOnlySpan[i] + value); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (short)(Math.Max(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (short)(Math.Min(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - - ret = value; - var hasValue = false; - value = (short)(readOnlySpan[i] + value); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (uint)(Math.Max(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (uint)(Math.Min(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - - ret = value; - var hasValue = false; - value = (uint)(readOnlySpan[i] + value); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (ulong)(Math.Max(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (ulong)(Math.Min(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - - ret = value; - var hasValue = false; - value = (ulong)(readOnlySpan[i] + value); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (ushort)(Math.Max(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - bool hasValue = false; - value = (ushort)(Math.Min(readOnlySpan[i], value)); - - ret = hasValue ? value : null; - - ret = value; - - ret = value; - var hasValue = false; - value = (ushort)(readOnlySpan[i] + value); - - ret = hasValue ? value : null; - - ret = value; { throw new NotImplementedException(); } diff --git a/test/Microsoft.Data.Analysis.Tests/DataFrame.IOTests.cs b/test/Microsoft.Data.Analysis.Tests/DataFrame.IOTests.cs index 3fd07cd705..29f55f668c 100644 --- a/test/Microsoft.Data.Analysis.Tests/DataFrame.IOTests.cs +++ b/test/Microsoft.Data.Analysis.Tests/DataFrame.IOTests.cs @@ -102,7 +102,7 @@ internal static void VerifyColumnTypes(DataFrame df, bool testArrowStringColumn } else if (dataType == typeof(DateTime)) { - Assert.IsType(column); + Assert.IsType>(column); } else { diff --git a/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs b/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs index 48db1c4e61..db26d1cf82 100644 --- a/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs +++ b/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs @@ -1225,20 +1225,6 @@ public void TestDateTimeComputations_MaxMin_WithNulls() Assert.Equal(new DateTime(2023, 1, 1), dateTimeColumn.Max()); } - var dateTimeColumn = new DateTimeDataFrameColumn("DateTime", new DateTime?[] - { - null, - new DateTime(2022, 1, 1), - new DateTime(2020, 1, 1), - new DateTime(2023, 1, 1), - new DateTime(2021, 1, 1), - null - }); - - Assert.Equal(new DateTime(2020, 1, 1), dateTimeColumn.Min()); - Assert.Equal(new DateTime(2023, 1, 1), dateTimeColumn.Max()); - } - [Theory] [InlineData(5, 10)] [InlineData(-15, 10)] From bd50494b9bef74500586564b37263dbb7c735172 Mon Sep 17 00:00:00 2001 From: Aleksei Smirnov Date: Thu, 13 Jul 2023 23:14:33 +0300 Subject: [PATCH 18/18] Fix merge issues --- .../FloatingPointDataFrameColumnArithmetic.cs | 86 +- .../IPrimitiveDataFrameColumnArithmetic.cs | 24 +- .../NumberDataFrameColumnArithmetic.cs | 11 + ...imitiveDataFrameColumn.BinaryOperations.cs | 136 ++-- .../PrimitiveDataFrameColumnArithmetic.cs | 744 ------------------ 5 files changed, 165 insertions(+), 836 deletions(-) diff --git a/src/Microsoft.Data.Analysis/FloatingPointDataFrameColumnArithmetic.cs b/src/Microsoft.Data.Analysis/FloatingPointDataFrameColumnArithmetic.cs index 9a776175d4..a4410bea62 100644 --- a/src/Microsoft.Data.Analysis/FloatingPointDataFrameColumnArithmetic.cs +++ b/src/Microsoft.Data.Analysis/FloatingPointDataFrameColumnArithmetic.cs @@ -16,6 +16,7 @@ internal class FloatingPointDataFrameColumnArithmetic : IPrimitiveDataFrameCo public FloatingPointDataFrameColumnArithmetic() : base() { } + public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -31,6 +32,7 @@ public void Add(PrimitiveColumnContainer left, PrimitiveColumnContainer ri } } } + public void Add(PrimitiveColumnContainer column, T scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -45,6 +47,7 @@ public void Add(PrimitiveColumnContainer column, T scalar) } } } + public void Add(T scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -59,6 +62,7 @@ public void Add(T scalar, PrimitiveColumnContainer column) } } } + public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -74,6 +78,7 @@ public void Subtract(PrimitiveColumnContainer left, PrimitiveColumnContainer< } } } + public void Subtract(PrimitiveColumnContainer column, T scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -88,6 +93,7 @@ public void Subtract(PrimitiveColumnContainer column, T scalar) } } } + public void Subtract(T scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -102,6 +108,7 @@ public void Subtract(T scalar, PrimitiveColumnContainer column) } } } + public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -117,6 +124,7 @@ public void Multiply(PrimitiveColumnContainer left, PrimitiveColumnContainer< } } } + public void Multiply(PrimitiveColumnContainer column, T scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -131,6 +139,7 @@ public void Multiply(PrimitiveColumnContainer column, T scalar) } } } + public void Multiply(T scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -145,6 +154,7 @@ public void Multiply(T scalar, PrimitiveColumnContainer column) } } } + public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -160,6 +170,7 @@ public void Divide(PrimitiveColumnContainer left, PrimitiveColumnContainer } } } + public void Divide(PrimitiveColumnContainer column, T scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -174,6 +185,7 @@ public void Divide(PrimitiveColumnContainer column, T scalar) } } } + public void Divide(T scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -188,6 +200,7 @@ public void Divide(T scalar, PrimitiveColumnContainer column) } } } + public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -203,6 +216,7 @@ public void Modulo(PrimitiveColumnContainer left, PrimitiveColumnContainer } } } + public void Modulo(PrimitiveColumnContainer column, T scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -217,6 +231,7 @@ public void Modulo(PrimitiveColumnContainer column, T scalar) } } } + public void Modulo(T scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -231,52 +246,65 @@ public void Modulo(T scalar, PrimitiveColumnContainer column) } } } + public virtual void And(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public virtual void And(PrimitiveColumnContainer column, T scalar) { throw new NotSupportedException(); } + public virtual void And(T scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public virtual void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public virtual void Or(PrimitiveColumnContainer column, T scalar) { throw new NotSupportedException(); } + public virtual void Or(T scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public virtual void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { throw new NotSupportedException(); } + public virtual void Xor(PrimitiveColumnContainer column, T scalar) { throw new NotSupportedException(); } + public virtual void Xor(T scalar, PrimitiveColumnContainer column) { throw new NotSupportedException(); } + public virtual void LeftShift(PrimitiveColumnContainer column, int value) { throw new NotSupportedException(); } + public virtual void RightShift(PrimitiveColumnContainer column, int value) { throw new NotSupportedException(); } - public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); for (int b = 0; b < left.Buffers.Count; b++) { var buffer = left.Buffers[b]; @@ -289,9 +317,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnC ret[i] = (span[i] == otherSpan[i]); } } + return ret; } - public void ElementwiseEquals(PrimitiveColumnContainer column, T scalar, PrimitiveColumnContainer ret) + + public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, T scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -303,9 +334,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer column, T scalar, Prim ret[i] = (span[i] == scalar); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); for (int b = 0; b < left.Buffers.Count; b++) { var buffer = left.Buffers[b]; @@ -318,9 +352,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColu ret[i] = (span[i] != otherSpan[i]); } } + return ret; } - public void ElementwiseNotEquals(PrimitiveColumnContainer column, T scalar, PrimitiveColumnContainer ret) + + public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, T scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -332,9 +369,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer column, T scalar, P ret[i] = (span[i] != scalar); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); for (int b = 0; b < left.Buffers.Count; b++) { var buffer = left.Buffers[b]; @@ -347,9 +387,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, Prim ret[i] = (span[i] >= otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, T scalar, PrimitiveColumnContainer ret) + + public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, T scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -361,9 +404,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, T ret[i] = (span[i] >= scalar); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); for (int b = 0; b < left.Buffers.Count; b++) { var buffer = left.Buffers[b]; @@ -376,9 +422,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, Primiti ret[i] = (span[i] <= otherSpan[i]); } } + return ret; } - public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, T scalar, PrimitiveColumnContainer ret) + + public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, T scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -390,9 +439,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, T sca ret[i] = (span[i] <= scalar); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); for (int b = 0; b < left.Buffers.Count; b++) { var buffer = left.Buffers[b]; @@ -405,9 +457,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveCo ret[i] = (span[i] > otherSpan[i]); } } + return ret; } - public void ElementwiseGreaterThan(PrimitiveColumnContainer column, T scalar, PrimitiveColumnContainer ret) + + public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, T scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -419,9 +474,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer column, T scalar, ret[i] = (span[i] > scalar); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); for (int b = 0; b < left.Buffers.Count; b++) { var buffer = left.Buffers[b]; @@ -434,9 +492,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColum ret[i] = (span[i] < otherSpan[i]); } } + return ret; } - public void ElementwiseLessThan(PrimitiveColumnContainer column, T scalar, PrimitiveColumnContainer ret) + + public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, T scalar) { + PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); for (int b = 0; b < column.Buffers.Count; b++) { var buffer = column.Buffers[b]; @@ -448,6 +509,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer column, T scalar, Pr ret[i] = (span[i] < scalar); } } + return ret; } } } diff --git a/src/Microsoft.Data.Analysis/IPrimitiveDataFrameColumnArithmetic.cs b/src/Microsoft.Data.Analysis/IPrimitiveDataFrameColumnArithmetic.cs index 23e178b41a..d439fec799 100644 --- a/src/Microsoft.Data.Analysis/IPrimitiveDataFrameColumnArithmetic.cs +++ b/src/Microsoft.Data.Analysis/IPrimitiveDataFrameColumnArithmetic.cs @@ -35,17 +35,17 @@ internal interface IPrimitiveDataFrameColumnArithmetic void Xor(T scalar, PrimitiveColumnContainer column); void LeftShift(PrimitiveColumnContainer column, int value); void RightShift(PrimitiveColumnContainer column, int value); - void ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret); - void ElementwiseEquals(PrimitiveColumnContainer column, T scalar, PrimitiveColumnContainer ret); - void ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret); - void ElementwiseNotEquals(PrimitiveColumnContainer column, T scalar, PrimitiveColumnContainer ret); - void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret); - void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, T scalar, PrimitiveColumnContainer ret); - void ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret); - void ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, T scalar, PrimitiveColumnContainer ret); - void ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret); - void ElementwiseGreaterThan(PrimitiveColumnContainer column, T scalar, PrimitiveColumnContainer ret); - void ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right, PrimitiveColumnContainer ret); - void ElementwiseLessThan(PrimitiveColumnContainer column, T scalar, PrimitiveColumnContainer ret); + PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right); + PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, T scalar); + PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right); + PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, T scalar); + PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right); + PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, T scalar); + PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right); + PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, T scalar); + PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right); + PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, T scalar); + PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right); + PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, T scalar); } } diff --git a/src/Microsoft.Data.Analysis/NumberDataFrameColumnArithmetic.cs b/src/Microsoft.Data.Analysis/NumberDataFrameColumnArithmetic.cs index b1dfde4678..639e85bf94 100644 --- a/src/Microsoft.Data.Analysis/NumberDataFrameColumnArithmetic.cs +++ b/src/Microsoft.Data.Analysis/NumberDataFrameColumnArithmetic.cs @@ -16,6 +16,7 @@ internal class NumberDataFrameColumnArithmetic : FloatingPointDataFrameColumn public NumberDataFrameColumnArithmetic() : base() { } + public override void And(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -31,6 +32,7 @@ public override void And(PrimitiveColumnContainer left, PrimitiveColumnContai } } } + public override void And(PrimitiveColumnContainer column, T scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -45,6 +47,7 @@ public override void And(PrimitiveColumnContainer column, T scalar) } } } + public override void And(T scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -59,6 +62,7 @@ public override void And(T scalar, PrimitiveColumnContainer column) } } } + public override void Or(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -74,6 +78,7 @@ public override void Or(PrimitiveColumnContainer left, PrimitiveColumnContain } } } + public override void Or(PrimitiveColumnContainer column, T scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -88,6 +93,7 @@ public override void Or(PrimitiveColumnContainer column, T scalar) } } } + public override void Or(T scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -102,6 +108,7 @@ public override void Or(T scalar, PrimitiveColumnContainer column) } } } + public override void Xor(PrimitiveColumnContainer left, PrimitiveColumnContainer right) { for (int b = 0; b < left.Buffers.Count; b++) @@ -117,6 +124,7 @@ public override void Xor(PrimitiveColumnContainer left, PrimitiveColumnContai } } } + public override void Xor(PrimitiveColumnContainer column, T scalar) { for (int b = 0; b < column.Buffers.Count; b++) @@ -131,6 +139,7 @@ public override void Xor(PrimitiveColumnContainer column, T scalar) } } } + public override void Xor(T scalar, PrimitiveColumnContainer column) { for (int b = 0; b < column.Buffers.Count; b++) @@ -145,6 +154,7 @@ public override void Xor(T scalar, PrimitiveColumnContainer column) } } } + public override void LeftShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) @@ -159,6 +169,7 @@ public override void LeftShift(PrimitiveColumnContainer column, int value) } } } + public override void RightShift(PrimitiveColumnContainer column, int value) { for (int b = 0; b < column.Buffers.Count; b++) diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs index b2f89858bb..f8c02fa7f2 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs @@ -2041,7 +2041,7 @@ internal PrimitiveDataFrameColumn ElementwiseEqualsImplementation(Primi { throw new NotSupportedException(); } - return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseEquals(column._columnContainer)); + return new PrimitiveDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseEquals(column._columnContainer)); case Type decimalType when decimalType == typeof(decimal): if (typeof(U) == typeof(bool)) { @@ -2051,19 +2051,19 @@ internal PrimitiveDataFrameColumn ElementwiseEqualsImplementation(Primi { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(column._columnContainer)); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(column._columnContainer)); } else { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseEquals(column.CloneAsDecimalColumn()._columnContainer)); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseEquals(column.CloneTruncating()._columnContainer)); } case Type DateTimeType when DateTimeType == typeof(DateTime): if (typeof(U) != typeof(DateTime)) { throw new NotSupportedException(); } - return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseEquals(column._columnContainer)); + return new PrimitiveDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseEquals(column._columnContainer)); case Type byteType when byteType == typeof(byte): case Type charType when charType == typeof(char): case Type doubleType when doubleType == typeof(double): @@ -2083,19 +2083,19 @@ internal PrimitiveDataFrameColumn ElementwiseEqualsImplementation(Primi { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(column._columnContainer)); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(column._columnContainer)); } else { if (typeof(U) == typeof(decimal)) { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseEquals((column as PrimitiveDataFrameColumn)._columnContainer)); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseEquals((column as PrimitiveDataFrameColumn)._columnContainer)); } else { PrimitiveDataFrameColumn doubleColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseEquals(column.CloneAsDoubleColumn()._columnContainer)); + return new PrimitiveDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseEquals(column.CloneTruncating()._columnContainer)); } } default: @@ -2112,7 +2112,7 @@ internal PrimitiveDataFrameColumn ElementwiseEqualsImplementation(U val { throw new NotSupportedException(); } - return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseEquals(Unsafe.As(ref value))); + return new PrimitiveDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseEquals(Unsafe.As(ref value))); case Type decimalType when decimalType == typeof(decimal): if (typeof(U) == typeof(bool)) { @@ -2122,19 +2122,19 @@ internal PrimitiveDataFrameColumn ElementwiseEqualsImplementation(U val { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(Unsafe.As(ref value))); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(Unsafe.As(ref value))); } else { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseEquals(DecimalConverter.Instance.GetDecimal(value))); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseEquals(GetDecimalValue(value))); } case Type DateTimeType when DateTimeType == typeof(DateTime): if (typeof(U) != typeof(DateTime)) { throw new NotSupportedException(); } - return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseEquals(Unsafe.As(ref value))); + return new PrimitiveDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseEquals(Unsafe.As(ref value))); case Type byteType when byteType == typeof(byte): case Type charType when charType == typeof(char): case Type doubleType when doubleType == typeof(double): @@ -2154,19 +2154,19 @@ internal PrimitiveDataFrameColumn ElementwiseEqualsImplementation(U val { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(Unsafe.As(ref value))); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(Unsafe.As(ref value))); } else { if (typeof(U) == typeof(decimal)) { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseEquals(DecimalConverter.Instance.GetDecimal(value))); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseEquals(GetDecimalValue(value))); } else { PrimitiveDataFrameColumn doubleColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseEquals(DoubleConverter.Instance.GetDouble(value))); + return new PrimitiveDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseEquals(GetDoubleValue(value))); } } default: @@ -2188,7 +2188,7 @@ internal PrimitiveDataFrameColumn ElementwiseNotEqualsImplementation(Pr { throw new NotSupportedException(); } - return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseNotEquals(column._columnContainer)); + return new PrimitiveDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseNotEquals(column._columnContainer)); case Type decimalType when decimalType == typeof(decimal): if (typeof(U) == typeof(bool)) { @@ -2198,19 +2198,19 @@ internal PrimitiveDataFrameColumn ElementwiseNotEqualsImplementation(Pr { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(column._columnContainer)); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(column._columnContainer)); } else { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseNotEquals(column.CloneAsDecimalColumn()._columnContainer)); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseNotEquals(column.CloneTruncating()._columnContainer)); } case Type DateTimeType when DateTimeType == typeof(DateTime): if (typeof(U) != typeof(DateTime)) { throw new NotSupportedException(); } - return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseNotEquals(column._columnContainer)); + return new PrimitiveDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseNotEquals(column._columnContainer)); case Type byteType when byteType == typeof(byte): case Type charType when charType == typeof(char): case Type doubleType when doubleType == typeof(double): @@ -2230,19 +2230,19 @@ internal PrimitiveDataFrameColumn ElementwiseNotEqualsImplementation(Pr { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(column._columnContainer)); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(column._columnContainer)); } else { if (typeof(U) == typeof(decimal)) { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseNotEquals((column as PrimitiveDataFrameColumn)._columnContainer)); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseNotEquals((column as PrimitiveDataFrameColumn)._columnContainer)); } else { PrimitiveDataFrameColumn doubleColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseNotEquals(column.CloneAsDoubleColumn()._columnContainer)); + return new PrimitiveDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseNotEquals(column.CloneTruncating()._columnContainer)); } } default: @@ -2259,7 +2259,7 @@ internal PrimitiveDataFrameColumn ElementwiseNotEqualsImplementation(U { throw new NotSupportedException(); } - return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseNotEquals(Unsafe.As(ref value))); + return new PrimitiveDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseNotEquals(Unsafe.As(ref value))); case Type decimalType when decimalType == typeof(decimal): if (typeof(U) == typeof(bool)) { @@ -2269,19 +2269,19 @@ internal PrimitiveDataFrameColumn ElementwiseNotEqualsImplementation(U { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(Unsafe.As(ref value))); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(Unsafe.As(ref value))); } else { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseNotEquals(DecimalConverter.Instance.GetDecimal(value))); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseNotEquals(GetDecimalValue(value))); } case Type DateTimeType when DateTimeType == typeof(DateTime): if (typeof(U) != typeof(DateTime)) { throw new NotSupportedException(); } - return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseNotEquals(Unsafe.As(ref value))); + return new PrimitiveDataFrameColumn(Name, (this as PrimitiveDataFrameColumn)._columnContainer.ElementwiseNotEquals(Unsafe.As(ref value))); case Type byteType when byteType == typeof(byte): case Type charType when charType == typeof(char): case Type doubleType when doubleType == typeof(double): @@ -2301,19 +2301,19 @@ internal PrimitiveDataFrameColumn ElementwiseNotEqualsImplementation(U { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(Unsafe.As(ref value))); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(Unsafe.As(ref value))); } else { if (typeof(U) == typeof(decimal)) { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseNotEquals(DecimalConverter.Instance.GetDecimal(value))); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseNotEquals(GetDecimalValue(value))); } else { PrimitiveDataFrameColumn doubleColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseNotEquals(DoubleConverter.Instance.GetDouble(value))); + return new PrimitiveDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseNotEquals(GetDoubleValue(value))); } } default: @@ -2341,12 +2341,12 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanOrEqualImplementat { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(column._columnContainer)); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(column._columnContainer)); } else { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(column.CloneAsDecimalColumn()._columnContainer)); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(column.CloneTruncating()._columnContainer)); } case Type DateTimeType when DateTimeType == typeof(DateTime): throw new NotSupportedException(); @@ -2369,19 +2369,19 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanOrEqualImplementat { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(column._columnContainer)); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(column._columnContainer)); } else { if (typeof(U) == typeof(decimal)) { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual((column as PrimitiveDataFrameColumn)._columnContainer)); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual((column as PrimitiveDataFrameColumn)._columnContainer)); } else { PrimitiveDataFrameColumn doubleColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThanOrEqual(column.CloneAsDoubleColumn()._columnContainer)); + return new PrimitiveDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThanOrEqual(column.CloneTruncating()._columnContainer)); } } default: @@ -2404,12 +2404,12 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanOrEqualImplementat { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(Unsafe.As(ref value))); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(Unsafe.As(ref value))); } else { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(DecimalConverter.Instance.GetDecimal(value))); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(GetDecimalValue(value))); } case Type DateTimeType when DateTimeType == typeof(DateTime): throw new NotSupportedException(); @@ -2432,19 +2432,19 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanOrEqualImplementat { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(Unsafe.As(ref value))); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(Unsafe.As(ref value))); } else { if (typeof(U) == typeof(decimal)) { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(DecimalConverter.Instance.GetDecimal(value))); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(GetDecimalValue(value))); } else { PrimitiveDataFrameColumn doubleColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThanOrEqual(DoubleConverter.Instance.GetDouble(value))); + return new PrimitiveDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThanOrEqual(GetDoubleValue(value))); } } default: @@ -2472,12 +2472,12 @@ internal PrimitiveDataFrameColumn ElementwiseLessThanOrEqualImplementation { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(column._columnContainer)); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(column._columnContainer)); } else { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual(column.CloneAsDecimalColumn()._columnContainer)); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual(column.CloneTruncating()._columnContainer)); } case Type DateTimeType when DateTimeType == typeof(DateTime): throw new NotSupportedException(); @@ -2500,19 +2500,19 @@ internal PrimitiveDataFrameColumn ElementwiseLessThanOrEqualImplementation { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(column._columnContainer)); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(column._columnContainer)); } else { if (typeof(U) == typeof(decimal)) { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual((column as PrimitiveDataFrameColumn)._columnContainer)); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual((column as PrimitiveDataFrameColumn)._columnContainer)); } else { PrimitiveDataFrameColumn doubleColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThanOrEqual(column.CloneAsDoubleColumn()._columnContainer)); + return new PrimitiveDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThanOrEqual(column.CloneTruncating()._columnContainer)); } } default: @@ -2535,12 +2535,12 @@ internal PrimitiveDataFrameColumn ElementwiseLessThanOrEqualImplementation { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(Unsafe.As(ref value))); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(Unsafe.As(ref value))); } else { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual(DecimalConverter.Instance.GetDecimal(value))); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual(GetDecimalValue(value))); } case Type DateTimeType when DateTimeType == typeof(DateTime): throw new NotSupportedException(); @@ -2563,19 +2563,19 @@ internal PrimitiveDataFrameColumn ElementwiseLessThanOrEqualImplementation { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(Unsafe.As(ref value))); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(Unsafe.As(ref value))); } else { if (typeof(U) == typeof(decimal)) { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual(DecimalConverter.Instance.GetDecimal(value))); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual(GetDecimalValue(value))); } else { PrimitiveDataFrameColumn doubleColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThanOrEqual(DoubleConverter.Instance.GetDouble(value))); + return new PrimitiveDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThanOrEqual(GetDoubleValue(value))); } } default: @@ -2603,12 +2603,12 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanImplementation( { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(column._columnContainer)); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(column._columnContainer)); } else { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan(column.CloneAsDecimalColumn()._columnContainer)); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan(column.CloneTruncating()._columnContainer)); } case Type DateTimeType when DateTimeType == typeof(DateTime): throw new NotSupportedException(); @@ -2631,19 +2631,19 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanImplementation( { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(column._columnContainer)); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(column._columnContainer)); } else { if (typeof(U) == typeof(decimal)) { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan((column as PrimitiveDataFrameColumn)._columnContainer)); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan((column as PrimitiveDataFrameColumn)._columnContainer)); } else { PrimitiveDataFrameColumn doubleColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThan(column.CloneAsDoubleColumn()._columnContainer)); + return new PrimitiveDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThan(column.CloneTruncating()._columnContainer)); } } default: @@ -2666,12 +2666,12 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanImplementation( { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(Unsafe.As(ref value))); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(Unsafe.As(ref value))); } else { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan(DecimalConverter.Instance.GetDecimal(value))); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan(GetDecimalValue(value))); } case Type DateTimeType when DateTimeType == typeof(DateTime): throw new NotSupportedException(); @@ -2694,19 +2694,19 @@ internal PrimitiveDataFrameColumn ElementwiseGreaterThanImplementation( { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(Unsafe.As(ref value))); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(Unsafe.As(ref value))); } else { if (typeof(U) == typeof(decimal)) { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan(DecimalConverter.Instance.GetDecimal(value))); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan(GetDecimalValue(value))); } else { PrimitiveDataFrameColumn doubleColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThan(DoubleConverter.Instance.GetDouble(value))); + return new PrimitiveDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThan(GetDoubleValue(value))); } } default: @@ -2734,12 +2734,12 @@ internal PrimitiveDataFrameColumn ElementwiseLessThanImplementation(Pri { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(column._columnContainer)); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(column._columnContainer)); } else { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan(column.CloneAsDecimalColumn()._columnContainer)); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan(column.CloneTruncating()._columnContainer)); } case Type DateTimeType when DateTimeType == typeof(DateTime): throw new NotSupportedException(); @@ -2762,19 +2762,19 @@ internal PrimitiveDataFrameColumn ElementwiseLessThanImplementation(Pri { // No conversions PrimitiveDataFrameColumn primitiveColumn = this as PrimitiveDataFrameColumn; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(column._columnContainer)); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(column._columnContainer)); } else { if (typeof(U) == typeof(decimal)) { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan((column as PrimitiveDataFrameColumn)._columnContainer)); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan((column as PrimitiveDataFrameColumn)._columnContainer)); } else { PrimitiveDataFrameColumn doubleColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThan(column.CloneAsDoubleColumn()._columnContainer)); + return new PrimitiveDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThan(column.CloneTruncating()._columnContainer)); } } default: @@ -2797,12 +2797,12 @@ internal PrimitiveDataFrameColumn ElementwiseLessThanImplementation(U v { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(Unsafe.As(ref value))); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(Unsafe.As(ref value))); } else { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan(DecimalConverter.Instance.GetDecimal(value))); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan(GetDecimalValue(value))); } case Type DateTimeType when DateTimeType == typeof(DateTime): throw new NotSupportedException(); @@ -2825,19 +2825,19 @@ internal PrimitiveDataFrameColumn ElementwiseLessThanImplementation(U v { // No conversions PrimitiveDataFrameColumn primitiveColumn = this; - return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(Unsafe.As(ref value))); + return new PrimitiveDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(Unsafe.As(ref value))); } else { if (typeof(U) == typeof(decimal)) { PrimitiveDataFrameColumn decimalColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan(DecimalConverter.Instance.GetDecimal(value))); + return new PrimitiveDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan(GetDecimalValue(value))); } else { PrimitiveDataFrameColumn doubleColumn = CloneTruncating(); - return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThan(DoubleConverter.Instance.GetDouble(value))); + return new PrimitiveDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThan(GetDoubleValue(value))); } } default: diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs index 901070662e..83da9220e1 100644 --- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs +++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs @@ -392,750 +392,6 @@ public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContain } } - - - - - - - - - - - - - - - - - - - - - - - - - - - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, byte scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, byte scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, byte scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, byte scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, byte scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, byte scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - - - - - - - - - - - - - - - - - - - - - - - - - - - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, char scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, char scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, char scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, char scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, char scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, char scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - - - - - - - - - - - - - - - - - - - - - - - - - - - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, decimal scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, decimal scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, decimal scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, decimal scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, decimal scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, decimal scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - - - - - - - - - - - - - - - - - - - - - - - - - - - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, double scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, double scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, double scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, double scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, double scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, double scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - - - - - - - - - - - - - - - - - - - - - - - - - - - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, float scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, float scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, float scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, float scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, float scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, float scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - - - - - - - - - - - - - - - - - - - - - - - - - - - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, int scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, int scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, int scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, int scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, int scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, int scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - - - - - - - - - - - - - - - - - - - - - - - - - - - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, long scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, long scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, long scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, long scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, long scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, long scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - - - - - - - - - - - - - - - - - - - - - - - - - - - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, sbyte scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, sbyte scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, sbyte scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, sbyte scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, sbyte scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, sbyte scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - - - - - - - - - - - - - - - - - - - - - - - - - - - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, short scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, short scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, short scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, short scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, short scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, short scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - - - - - - - - - - - - - - - - - - - - - - - - - - - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, uint scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, uint scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, uint scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, uint scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, uint scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, uint scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - - - - - - - - - - - - - - - - - - - - - - - - - - - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, ulong scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, ulong scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, ulong scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ulong scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, ulong scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, ulong scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - - - - - - - - - - - - - - - - - - - - - - - - - - - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseEquals(PrimitiveColumnContainer column, ushort scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseNotEquals(PrimitiveColumnContainer column, ushort scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer column, ushort scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThanOrEqual(PrimitiveColumnContainer column, ushort scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseGreaterThan(PrimitiveColumnContainer column, ushort scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer left, PrimitiveColumnContainer right) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(left.Length); - return ret; - public PrimitiveColumnContainer ElementwiseLessThan(PrimitiveColumnContainer column, ushort scalar) - PrimitiveColumnContainer ret = new PrimitiveColumnContainer(column.Length); - return ret; internal class DateTimeArithmetic : IPrimitiveDataFrameColumnArithmetic {