diff --git a/THIRD-PARTY-NOTICES.TXT b/THIRD-PARTY-NOTICES.TXT
index 3ec43d38e4..890b399349 100644
--- a/THIRD-PARTY-NOTICES.TXT
+++ b/THIRD-PARTY-NOTICES.TXT
@@ -85,3 +85,24 @@ distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
+
+
+License notice for BitUtility
+------------------------------------------
+
+https://github.com/apache/arrow/blob/main/csharp/src/Apache.Arrow/BitUtility.cs
+
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements. See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/src/Microsoft.Data.Analysis/BitUtility.cs b/src/Microsoft.Data.Analysis/BitUtility.cs
new file mode 100644
index 0000000000..783356dd13
--- /dev/null
+++ b/src/Microsoft.Data.Analysis/BitUtility.cs
@@ -0,0 +1,177 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Data.Analysis
+{
+    // License for BitUtility
+    // --------------------------------------
+    // This class is based on the code from Apache Arrow project 
+    // https://github.com/apache/arrow/blob/main/csharp/src/Apache.Arrow/BitUtility.cs
+    // that is available in the public domain inder Apache-2.0 license.
+    // You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0
+    internal static class BitUtility
+    {
+        private static ReadOnlySpan<byte> PopcountTable => new byte[] {
+            0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+            1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+            1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+            2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+            1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+            2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+            2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+            3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
+        };
+
+        private static ReadOnlySpan<byte> BitMask => new byte[] {
+            1, 2, 4, 8, 16, 32, 64, 128
+        };
+
+        // Faster to use when we already have a span since it avoids indexing
+        public static bool IsValid(ReadOnlySpan<byte> bitMapBufferSpan, int index)
+        {
+            var nullBitMapSpanIndex = index / 8;
+            var thisBitMap = bitMapBufferSpan[nullBitMapSpanIndex];
+            return IsBitSet(thisBitMap, index);
+        }
+
+        public static bool IsBitSet(byte curBitMap, int index)
+        {
+            return ((curBitMap >> (index & 7)) & 1) != 0;
+        }
+
+        public static bool IsBitClear(byte curBitMap, int index)
+        {
+            return ((curBitMap >> (index & 7)) & 1) == 0;
+        }
+
+        public static bool GetBit(byte data, int index) =>
+           ((data >> index) & 1) != 0;
+
+        public static bool GetBit(ReadOnlySpan<byte> data, int index) =>
+            (data[index / 8] & BitMask[index % 8]) != 0;
+
+        public static void ClearBit(Span<byte> data, int index)
+        {
+            data[index / 8] &= (byte)~BitMask[index % 8];
+        }
+
+        public static void SetBit(Span<byte> data, int index)
+        {
+            data[index / 8] |= BitMask[index % 8];
+        }
+
+        public static void SetBit(Span<byte> data, long index, bool value)
+        {
+            int idx = (int)(index / 8);
+            int mod = (int)(index % 8);
+            data[idx] = value
+                ? (byte)(data[idx] | BitMask[mod])
+                : (byte)(data[idx] & ~BitMask[mod]);
+        }
+
+        /// <summary>
+        /// Set the number of bits in a span of bytes starting
+        /// at a specific index, and limiting to length.
+        /// </summary>
+        /// <param name="data">Span to set bits value.</param>
+        /// <param name="index">Bit index to start counting from.</param>
+        /// <param name="length">Maximum of bits in the span to consider.</param>
+        /// <param name="value">Bit value.</param>
+        public static void SetBits(Span<byte> data, long index, long length, bool value)
+        {
+            if (length == 0)
+                return;
+
+            var endBitIndex = index + length - 1;
+
+            // Use simpler method if there aren't many values
+            if (length < 20)
+            {
+                for (var i = index; i <= endBitIndex; i++)
+                {
+                    SetBit(data, i, value);
+                }
+                return;
+            }
+
+            // Otherwise do the work to figure out how to copy whole bytes
+            var startByteIndex = (int)(index / 8);
+            var startBitOffset = (int)(index % 8);
+            var endByteIndex = (int)(endBitIndex / 8);
+            var endBitOffset = (int)(endBitIndex % 8);
+
+            // If the starting index and ending index are not byte-aligned,
+            // we'll need to set bits the slow way. If they are
+            // byte-aligned, and for all other bytes in the 'middle', we
+            // can use a faster byte-aligned set.
+            var fullByteStartIndex = startBitOffset == 0 ? startByteIndex : startByteIndex + 1;
+            var fullByteEndIndex = endBitOffset == 7 ? endByteIndex : endByteIndex - 1;
+
+            // Bits we will be using to finish up the first byte
+            if (startBitOffset != 0)
+            {
+                var slice = data.Slice(startByteIndex, 1);
+                for (var i = startBitOffset; i <= 7; i++)
+                    SetBit(slice, i, value);
+            }
+
+            if (fullByteEndIndex >= fullByteStartIndex)
+            {
+                var slice = data.Slice(fullByteStartIndex, fullByteEndIndex - fullByteStartIndex + 1);
+                byte fill = (byte)(value ? 0xFF : 0x00);
+
+                slice.Fill(fill);
+            }
+
+            if (endBitOffset != 7)
+            {
+                var slice = data.Slice(endByteIndex, 1);
+                for (int i = 0; i <= endBitOffset; i++)
+                    SetBit(slice, i, value);
+            }
+        }
+
+        public static void ElementwiseAnd(ReadOnlySpan<byte> left, ReadOnlySpan<byte> right, Span<byte> result)
+        {
+            for (var i = 0; i < left.Length; i++)
+                result[i] = (byte)(left[i] & right[i]);
+        }
+
+        /// <summary>
+        /// Returns the population count (number of bits set) in a span of bytes starting
+        /// at 0 bit and limiting to length of bits.
+        /// </summary>
+        /// <param name="span"></param>
+        /// <param name="length"></param>
+        /// <returns></returns>
+        public static long GetBitCount(ReadOnlySpan<byte> span, long length)
+        {
+            var endByteIndex = (int)(length / 8);
+
+            Debug.Assert(span.Length > endByteIndex);
+
+            long count = 0;
+            for (var i = 0; i < endByteIndex; i++)
+                count += PopcountTable[span[i]];
+
+            var endBitOffset = (int)(length % 8);
+
+            if (endBitOffset != 0)
+            {
+                var partialByte = span[endByteIndex];
+                for (var j = 0; j < endBitOffset; j++)
+                {
+                    count += GetBit(partialByte, j) ? 0 : 1;
+                }
+            }
+
+            return count;
+        }
+    }
+}
diff --git a/src/Microsoft.Data.Analysis/ColumnArithmetic.OperationEnums.cs b/src/Microsoft.Data.Analysis/ColumnArithmetic.OperationEnums.cs
new file mode 100644
index 0000000000..79d1314520
--- /dev/null
+++ b/src/Microsoft.Data.Analysis/ColumnArithmetic.OperationEnums.cs
@@ -0,0 +1,58 @@
+
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// Generated from ColumnArithmetic.OperationEnums.tt. Do not modify directly
+namespace Microsoft.Data.Analysis
+{
+    internal enum BinaryOperation
+    {
+        Add,
+        Subtract,
+        Multiply,
+        Divide,
+        Modulo,
+        And,
+        Or,
+        Xor,
+    }
+
+    internal enum BinaryScalarOperation
+    {
+        Add,
+        Subtract,
+        Multiply,
+        Divide,
+        Modulo,
+        And,
+        Or,
+        Xor,
+    }
+
+    internal enum BinaryIntOperation
+    {
+        LeftShift,
+        RightShift,
+    }
+
+    internal enum ComparisonOperation
+    {
+        ElementwiseEquals,
+        ElementwiseNotEquals,
+        ElementwiseGreaterThanOrEqual,
+        ElementwiseLessThanOrEqual,
+        ElementwiseGreaterThan,
+        ElementwiseLessThan,
+    }
+
+    internal enum ComparisonScalarOperation
+    {
+        ElementwiseEquals,
+        ElementwiseNotEquals,
+        ElementwiseGreaterThanOrEqual,
+        ElementwiseLessThanOrEqual,
+        ElementwiseGreaterThan,
+        ElementwiseLessThan,
+    }
+}
\ No newline at end of file
diff --git a/src/Microsoft.Data.Analysis/ColumnArithmetic.OperationEnums.tt b/src/Microsoft.Data.Analysis/ColumnArithmetic.OperationEnums.tt
new file mode 100644
index 0000000000..273091a8e7
--- /dev/null
+++ b/src/Microsoft.Data.Analysis/ColumnArithmetic.OperationEnums.tt
@@ -0,0 +1,59 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ output extension=".cs" #>
+<#@ include file="ColumnArithmeticTemplate.ttinclude" #>
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// Generated from ColumnArithmetic.OperationEnums.tt. Do not modify directly
+namespace Microsoft.Data.Analysis
+{
+    internal enum BinaryOperation
+    {
+<# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (method.MethodType == MethodType.Binary) { #>
+        <#=method.MethodName#>,
+<# } #>
+<# } #>
+    }
+
+    internal enum BinaryScalarOperation
+    {
+<# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (method.MethodType == MethodType.BinaryScalar) { #>
+        <#=method.MethodName#>,
+<# } #>
+<# } #>
+    }
+
+    internal enum BinaryIntOperation
+    {
+<# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (method.MethodType == MethodType.BinaryInt) { #>
+        <#=method.MethodName#>,
+<# } #>
+<# } #>
+    }
+
+    internal enum ComparisonOperation
+    {
+<# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (method.MethodType == MethodType.Comparison) { #>
+        <#=method.MethodName#>,
+<# } #>
+<# } #>
+    }
+
+    internal enum ComparisonScalarOperation
+    {
+<# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (method.MethodType == MethodType.ComparisonScalar) { #>
+        <#=method.MethodName#>,
+<# } #>
+<# } #>
+    }
+}
\ No newline at end of file
diff --git a/src/Microsoft.Data.Analysis/DataFrameBuffer.cs b/src/Microsoft.Data.Analysis/DataFrameBuffer.cs
index fd7f23964f..e93d6d4237 100644
--- a/src/Microsoft.Data.Analysis/DataFrameBuffer.cs
+++ b/src/Microsoft.Data.Analysis/DataFrameBuffer.cs
@@ -106,7 +106,6 @@ internal static DataFrameBuffer<T> GetMutableBuffer(ReadOnlyDataFrameBuffer<T> b
             if (mutableBuffer == null)
             {
                 mutableBuffer = new DataFrameBuffer<T>(buffer.ReadOnlyBuffer, buffer.Length);
-                mutableBuffer.Length = buffer.Length;
             }
             return mutableBuffer;
         }
diff --git a/src/Microsoft.Data.Analysis/DateTimeComputation.cs b/src/Microsoft.Data.Analysis/DateTimeComputation.cs
index ef052b4011..33f643cfea 100644
--- a/src/Microsoft.Data.Analysis/DateTimeComputation.cs
+++ b/src/Microsoft.Data.Analysis/DateTimeComputation.cs
@@ -203,7 +203,7 @@ public void Max(PrimitiveColumnContainer<DateTime> column, out DateTime? ret)
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
                     //Check if bit is not set (value is null) - skip
-                    if (!BitmapHelper.IsValid(bitmapSpan, i))
+                    if (!BitUtility.IsValid(bitmapSpan, i))
                         continue;
 
                     var val = readOnlySpan[i];
@@ -261,7 +261,7 @@ public void Min(PrimitiveColumnContainer<DateTime> column, out DateTime? ret)
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
                     //Check if bit is not set (value is null) - skip
-                    if (!BitmapHelper.IsValid(bitmapSpan, i))
+                    if (!BitUtility.IsValid(bitmapSpan, i))
                         continue;
 
                     var val = readOnlySpan[i];
diff --git a/src/Microsoft.Data.Analysis/IPrimitiveDataFrameColumnArithmetic.cs b/src/Microsoft.Data.Analysis/IPrimitiveDataFrameColumnArithmetic.cs
new file mode 100644
index 0000000000..780c2000e8
--- /dev/null
+++ b/src/Microsoft.Data.Analysis/IPrimitiveDataFrameColumnArithmetic.cs
@@ -0,0 +1,24 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Microsoft.Data.Analysis
+{
+    internal interface IPrimitiveDataFrameColumnArithmetic<T>
+        where T : unmanaged
+    {
+        void HandleOperation(BinaryOperation operation, Span<T> left, Span<byte> leftValidity, ReadOnlySpan<T> right, ReadOnlySpan<byte> rightValidity);
+
+        void HandleOperation(ComparisonOperation operation, ReadOnlySpan<T> left, ReadOnlySpan<T> right, PrimitiveColumnContainer<bool> container, long offset);
+        void HandleOperation(ComparisonScalarOperation operation, ReadOnlySpan<T> left, T right, PrimitiveColumnContainer<bool> container, long offset);
+
+        void HandleOperation(BinaryScalarOperation operation, Span<T> left, T right);
+        void HandleOperation(BinaryScalarOperation operation, T left, Span<T> right, ReadOnlySpan<byte> rightValidity);
+
+        void HandleOperation(BinaryIntOperation operation, Span<T> left, int right);
+    }
+}
diff --git a/src/Microsoft.Data.Analysis/Microsoft.Data.Analysis.csproj b/src/Microsoft.Data.Analysis/Microsoft.Data.Analysis.csproj
index acfcd62199..ed9f74ce97 100644
--- a/src/Microsoft.Data.Analysis/Microsoft.Data.Analysis.csproj
+++ b/src/Microsoft.Data.Analysis/Microsoft.Data.Analysis.csproj
@@ -54,6 +54,10 @@
   </ItemGroup>
 
   <ItemGroup>
+    <None Update="ColumnArithmetic.OperationEnums.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>ColumnArithmetic.OperationEnums.cs</LastGenOutput>
+    </None>
     <None Update="Converters.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>Converters.cs</LastGenOutput>
@@ -111,10 +115,6 @@
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>PrimitiveDataFrameColumn.Computations.cs</LastGenOutput>
     </None>
-    <None Update="PrimitiveDataFrameColumn.ReversedBinaryOperations.tt">
-      <Generator>TextTemplatingFileGenerator</Generator>
-      <LastGenOutput>PrimitiveDataFrameColumn.ReversedBinaryOperations.cs</LastGenOutput>
-    </None>
     <None Update="PrimitiveDataFrameColumnArithmetic.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>PrimitiveColumnArithmetic.cs</LastGenOutput>
@@ -123,18 +123,10 @@
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>PrimitiveDataFrameColumnComputations.cs</LastGenOutput>
     </None>
-    <None Update="PrimitiveColumnContainer.BinaryOperations.tt">
-      <Generator>TextTemplatingFileGenerator</Generator>
-      <LastGenOutput>PrimitiveColumnContainer.BinaryOperations.cs</LastGenOutput>
-    </None>
     <None Update="PrimitiveDataFrameColumnArithmetic.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>PrimitiveDataFrameColumnArithmetic.cs</LastGenOutput>
     </None>
-    <None Update="PrimitiveColumnContainer.BinaryOperations.tt">
-      <Generator>TextTemplatingFileGenerator</Generator>
-      <LastGenOutput>PrimitiveColumnContainer.BinaryOperations.cs</LastGenOutput>
-    </None>
   </ItemGroup>
 
   <ItemGroup>
@@ -147,6 +139,11 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>Converters.tt</DependentUpon>
     </Compile>
+    <Compile Update="ColumnArithmetic.OperationEnums.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>ColumnArithmetic.OperationEnums.tt</DependentUpon>
+    </Compile>
     <Compile Update="PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
@@ -202,11 +199,6 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>PrimitiveDataFrameColumn.Computations.tt</DependentUpon>
     </Compile>
-    <Compile Update="PrimitiveDataFrameColumn.ReversedBinaryOperations.cs">
-      <DesignTime>True</DesignTime>
-      <AutoGen>True</AutoGen>
-      <DependentUpon>PrimitiveDataFrameColumn.ReversedBinaryOperations.tt</DependentUpon>
-    </Compile>
     <Compile Update="PrimitiveDataFrameColumnArithmetic.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
@@ -217,21 +209,11 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>PrimitiveDataFrameColumnComputations.tt</DependentUpon>
     </Compile>
-    <Compile Update="PrimitiveColumnContainer.BinaryOperations.cs">
-      <DesignTime>True</DesignTime>
-      <AutoGen>True</AutoGen>
-      <DependentUpon>PrimitiveColumnContainer.BinaryOperations.tt</DependentUpon>
-    </Compile>
     <Compile Update="PrimitiveDataFrameColumnArithmetic.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
       <DependentUpon>PrimitiveDataFrameColumnArithmetic.tt</DependentUpon>
     </Compile>
-    <Compile Update="PrimitiveColumnContainer.BinaryOperations.cs">
-      <DesignTime>True</DesignTime>
-      <AutoGen>True</AutoGen>
-      <DependentUpon>PrimitiveColumnContainer.BinaryOperations.tt</DependentUpon>
-    </Compile>
     <Compile Update="Strings.Designer.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs
index ca16f01489..58180924a8 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs
@@ -1,230 +1,108 @@
-
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-// Generated from PrimitiveColumnContainer.BinaryOperations.tt. Do not modify directly
+using System;
 
 namespace Microsoft.Data.Analysis
 {
     internal partial class PrimitiveColumnContainer<T>
         where T : unmanaged
     {
-
-        public PrimitiveColumnContainer<T> Add(PrimitiveColumnContainer<T> right)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Add(this, right);
-            return this;
-        }
-
-        public PrimitiveColumnContainer<T> Add(T scalar)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Add(this, scalar);
-            return this;
-        }
-
-        public PrimitiveColumnContainer<T> Subtract(PrimitiveColumnContainer<T> right)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Subtract(this, right);
-            return this;
-        }
-
-        public PrimitiveColumnContainer<T> Subtract(T scalar)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Subtract(this, scalar);
-            return this;
-        }
-
-        public PrimitiveColumnContainer<T> Multiply(PrimitiveColumnContainer<T> right)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Multiply(this, right);
-            return this;
-        }
-
-        public PrimitiveColumnContainer<T> Multiply(T scalar)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Multiply(this, scalar);
-            return this;
-        }
-
-        public PrimitiveColumnContainer<T> Divide(PrimitiveColumnContainer<T> right)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Divide(this, right);
-            return this;
-        }
-
-        public PrimitiveColumnContainer<T> Divide(T scalar)
+        public PrimitiveColumnContainer<T> HandleOperation(BinaryOperation operation, PrimitiveColumnContainer<T> right)
         {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Divide(this, scalar);
-            return this;
-        }
+            var arithmetic = PrimitiveDataFrameColumnArithmetic<T>.Instance;
+            long nullCount = 0;
+            for (int i = 0; i < this.Buffers.Count; i++)
+            {
+                var mutableBuffer = this.Buffers.GetOrCreateMutable(i);
+                var leftSpan = mutableBuffer.Span;
+                var rightSpan = right.Buffers[i].ReadOnlySpan;
 
-        public PrimitiveColumnContainer<T> Modulo(PrimitiveColumnContainer<T> right)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Modulo(this, right);
-            return this;
-        }
+                var leftValidity = this.NullBitMapBuffers.GetOrCreateMutable(i).Span;
+                var rightValidity = right.NullBitMapBuffers[i].ReadOnlySpan;
 
-        public PrimitiveColumnContainer<T> Modulo(T scalar)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Modulo(this, scalar);
-            return this;
-        }
+                arithmetic.HandleOperation(operation, leftSpan, leftValidity, rightSpan, rightValidity);
 
-        public PrimitiveColumnContainer<T> And(PrimitiveColumnContainer<T> right)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.And(this, right);
-            return this;
-        }
+                //Calculate NullCount
+                nullCount += BitUtility.GetBitCount(leftValidity, mutableBuffer.Length);
+            }
 
-        public PrimitiveColumnContainer<T> And(T scalar)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.And(this, scalar);
+            NullCount = nullCount;
             return this;
         }
 
-        public PrimitiveColumnContainer<T> Or(PrimitiveColumnContainer<T> right)
+        public PrimitiveColumnContainer<T> HandleOperation(BinaryScalarOperation operation, T right)
         {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Or(this, right);
-            return this;
-        }
+            var arithmetic = PrimitiveDataFrameColumnArithmetic<T>.Instance;
+            for (int i = 0; i < this.Buffers.Count; i++)
+            {
+                var leftSpan = this.Buffers.GetOrCreateMutable(i).Span;
 
-        public PrimitiveColumnContainer<T> Or(T scalar)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Or(this, scalar);
-            return this;
-        }
+                arithmetic.HandleOperation(operation, leftSpan, right);
+            }
 
-        public PrimitiveColumnContainer<T> Xor(PrimitiveColumnContainer<T> right)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Xor(this, right);
             return this;
         }
 
-        public PrimitiveColumnContainer<T> Xor(T scalar)
+        public PrimitiveColumnContainer<T> HandleReverseOperation(BinaryScalarOperation operation, T left)
         {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Xor(this, scalar);
-            return this;
-        }
+            var arithmetic = PrimitiveDataFrameColumnArithmetic<T>.Instance;
+            for (int i = 0; i < this.Buffers.Count; i++)
+            {
+                var rightSpan = this.Buffers.GetOrCreateMutable(i).Span;
+                var rightValidity = this.NullBitMapBuffers[i].ReadOnlySpan;
 
-        public PrimitiveColumnContainer<T> LeftShift(int value)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.LeftShift(this, value);
-            return this;
-        }
+                arithmetic.HandleOperation(operation, left, rightSpan, rightValidity);
+            }
 
-        public PrimitiveColumnContainer<T> RightShift(int value)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.RightShift(this, value);
             return this;
         }
 
-        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<T> right)
-        {
-            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseEquals(this, right);
-        }
-
-        public PrimitiveColumnContainer<bool> ElementwiseEquals(T scalar)
-        {
-            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseEquals(this, scalar);
-        }
-
-        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<T> right)
-        {
-            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseNotEquals(this, right);
-        }
-
-        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(T scalar)
-        {
-            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseNotEquals(this, scalar);
-        }
-
-        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<T> right)
-        {
-            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThanOrEqual(this, right);
-        }
-
-        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(T scalar)
-        {
-            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThanOrEqual(this, scalar);
-        }
-
-        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<T> right)
-        {
-            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThanOrEqual(this, right);
-        }
-
-        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(T scalar)
-        {
-            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThanOrEqual(this, scalar);
-        }
-
-        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<T> right)
-        {
-            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThan(this, right);
-        }
-
-        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(T scalar)
+        public PrimitiveColumnContainer<T> HandleOperation(BinaryIntOperation operation, int right)
         {
-            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThan(this, scalar);
-        }
+            var arithmetic = PrimitiveDataFrameColumnArithmetic<T>.Instance;
+            for (int i = 0; i < this.Buffers.Count; i++)
+            {
+                var leftSpan = this.Buffers.GetOrCreateMutable(i).Span;
 
-        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<T> right)
-        {
-            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThan(this, right);
-        }
+                arithmetic.HandleOperation(operation, leftSpan, right);
+            }
 
-        public PrimitiveColumnContainer<bool> ElementwiseLessThan(T scalar)
-        {
-            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThan(this, scalar);
-        }
-
-        public PrimitiveColumnContainer<T> ReverseAdd(T scalar)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Add(scalar, this);
             return this;
         }
 
-        public PrimitiveColumnContainer<T> ReverseSubtract(T scalar)
+        public PrimitiveColumnContainer<bool> HandleOperation(ComparisonOperation operation, PrimitiveColumnContainer<T> right)
         {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Subtract(scalar, this);
-            return this;
-        }
+            var arithmetic = PrimitiveDataFrameColumnArithmetic<T>.Instance;
 
-        public PrimitiveColumnContainer<T> ReverseMultiply(T scalar)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Multiply(scalar, this);
-            return this;
-        }
+            var ret = new PrimitiveColumnContainer<bool>(Length);
+            long offset = 0;
+            for (int i = 0; i < this.Buffers.Count; i++)
+            {
+                var leftSpan = this.Buffers[i].ReadOnlySpan;
+                var rightSpan = right.Buffers[i].ReadOnlySpan;
 
-        public PrimitiveColumnContainer<T> ReverseDivide(T scalar)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Divide(scalar, this);
-            return this;
-        }
+                arithmetic.HandleOperation(operation, leftSpan, rightSpan, ret, offset);
+                offset += leftSpan.Length;
+            }
 
-        public PrimitiveColumnContainer<T> ReverseModulo(T scalar)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Modulo(scalar, this);
-            return this;
+            return ret;
         }
 
-        public PrimitiveColumnContainer<T> ReverseAnd(T scalar)
+        public PrimitiveColumnContainer<bool> HandleOperation(ComparisonScalarOperation operation, T right)
         {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.And(scalar, this);
-            return this;
-        }
+            var ret = new PrimitiveColumnContainer<bool>(Length);
+            long offset = 0;
+            var arithmetic = PrimitiveDataFrameColumnArithmetic<T>.Instance;
+            for (int i = 0; i < this.Buffers.Count; i++)
+            {
+                var leftSpan = this.Buffers[i].ReadOnlySpan;
 
-        public PrimitiveColumnContainer<T> ReverseOr(T scalar)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Or(scalar, this);
-            return this;
-        }
+                arithmetic.HandleOperation(operation, leftSpan, right, ret, offset);
+            }
 
-        public PrimitiveColumnContainer<T> ReverseXor(T scalar)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.Xor(scalar, this);
-            return this;
+            return ret;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt
deleted file mode 100644
index 4af33da261..0000000000
--- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt
+++ /dev/null
@@ -1,56 +0,0 @@
-<#@ template debug="false" hostspecific="false" language="C#" #>
-<#@ assembly name="System.Core" #>
-<#@ import namespace="System.Linq" #>
-<#@ import namespace="System.Text" #>
-<#@ import namespace="System.Collections.Generic" #>
-<#@ output extension=".cs" #>
-<#@ include file="ColumnArithmeticTemplate.ttinclude" #>
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-// Generated from PrimitiveColumnContainer.BinaryOperations.tt. Do not modify directly
-
-namespace Microsoft.Data.Analysis
-{
-    internal partial class PrimitiveColumnContainer<T>
-        where T : unmanaged
-    {
-<# foreach (MethodConfiguration method in methodConfiguration) { #>
-
-<# if (method.MethodType == MethodType.Comparison) { #>
-        public PrimitiveColumnContainer<bool> <#=method.MethodName#>(PrimitiveColumnContainer<T> right)
-        {
-            return PrimitiveDataFrameColumnArithmetic<T>.Instance.<#=method.MethodName#>(this, right);
-        }
-<# } else if (method.MethodType == MethodType.ComparisonScalar ) { #>
-        public PrimitiveColumnContainer<bool> <#=method.MethodName#>(T scalar)
-        {
-            return PrimitiveDataFrameColumnArithmetic<T>.Instance.<#=method.MethodName#>(this, scalar);
-        }
-<# } else { #>
-        public <#= method.GetSingleArgumentMethodSignature("PrimitiveColumnContainer", "T")#>
-        {
-<# if (method.MethodType == MethodType.BinaryScalar) { #>
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.<#=method.MethodName#>(this, scalar);
-<# } else if (method.MethodType == MethodType.BinaryInt) { #>
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.<#=method.MethodName#>(this, value);
-<# } else { #>
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.<#=method.MethodName#>(this, right);
-<# } #>
-            return this;
-        }
-<# } #>
-<# } #>
-<# foreach (MethodConfiguration method in methodConfiguration) { #>
-<# if (method.MethodType == MethodType.BinaryScalar) { #>
-
-        public PrimitiveColumnContainer<T> Reverse<#=method.MethodName#>(T scalar)
-        {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.<#=method.MethodName#>(scalar, this);
-            return this;
-        }
-<# } #>
-<# } #>
-    }
-}
\ No newline at end of file
diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs
index 1824e595ae..ce4c074c64 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.cs
@@ -12,118 +12,6 @@
 
 namespace Microsoft.Data.Analysis
 {
-    internal static class BitmapHelper
-    {
-        private static ReadOnlySpan<byte> BitMask => new byte[] {
-            1, 2, 4, 8, 16, 32, 64, 128
-        };
-
-        // Faster to use when we already have a span since it avoids indexing
-        public static bool IsValid(ReadOnlySpan<byte> 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;
-        }
-
-        public static bool IsBitClear(byte curBitMap, int index)
-        {
-            return ((curBitMap >> (index & 7)) & 1) == 0;
-        }
-
-        public static bool GetBit(byte data, int index) =>
-           ((data >> index) & 1) != 0;
-
-        public static bool GetBit(ReadOnlySpan<byte> data, int index) =>
-            (data[index / 8] & BitMask[index % 8]) != 0;
-
-        public static void ClearBit(Span<byte> data, int index)
-        {
-            data[index / 8] &= (byte)~BitMask[index % 8];
-        }
-
-        public static void SetBit(Span<byte> data, int index)
-        {
-            data[index / 8] |= BitMask[index % 8];
-        }
-
-        public static void SetBit(Span<byte> data, int index, bool value)
-        {
-            int idx = index / 8;
-            int mod = index % 8;
-            data[idx] = value
-                ? (byte)(data[idx] | BitMask[mod])
-                : (byte)(data[idx] & ~BitMask[mod]);
-        }
-
-        /// <summary>
-        /// Set the number of bits in a span of bytes starting
-        /// at a specific index, and limiting to length.
-        /// </summary>
-        /// <param name="data">Span to set bits value.</param>
-        /// <param name="index">Bit index to start counting from.</param>
-        /// <param name="length">Maximum of bits in the span to consider.</param>
-        /// <param name="value">Bit value.</param>
-        internal static void SetBits(Span<byte> data, int index, int length, bool value)
-        {
-            if (length == 0)
-                return;
-
-            int endBitIndex = checked(index + length - 1);
-
-            // Use simpler method if there aren't many values
-            if (length < 20)
-            {
-                for (int i = index; i <= endBitIndex; i++)
-                {
-                    SetBit(data, i, value);
-                }
-                return;
-            }
-
-            // Otherwise do the work to figure out how to copy whole bytes
-            int startByteIndex = index / 8;
-            int startBitOffset = index % 8;
-            int endByteIndex = endBitIndex / 8;
-            int endBitOffset = endBitIndex % 8;
-
-            // If the starting index and ending index are not byte-aligned,
-            // we'll need to set bits the slow way. If they are
-            // byte-aligned, and for all other bytes in the 'middle', we
-            // can use a faster byte-aligned set.
-            int fullByteStartIndex = startBitOffset == 0 ? startByteIndex : startByteIndex + 1;
-            int fullByteEndIndex = endBitOffset == 7 ? endByteIndex : endByteIndex - 1;
-
-            // Bits we will be using to finish up the first byte
-            if (startBitOffset != 0)
-            {
-                Span<byte> slice = data.Slice(startByteIndex, 1);
-                for (int i = startBitOffset; i <= 7; i++)
-                    SetBit(slice, i, value);
-            }
-
-            if (fullByteEndIndex >= fullByteStartIndex)
-            {
-                Span<byte> slice = data.Slice(fullByteStartIndex, fullByteEndIndex - fullByteStartIndex + 1);
-                byte fill = (byte)(value ? 0xFF : 0x00);
-
-                slice.Fill(fill);
-            }
-
-            if (endBitOffset != 7)
-            {
-                Span<byte> slice = data.Slice(endByteIndex, 1);
-                for (int i = 0; i <= endBitOffset; i++)
-                    SetBit(slice, i, value);
-            }
-        }
-    }
-
     /// <summary>
     /// PrimitiveColumnContainer is just a store for the column data. APIs that want to change the data must be defined in PrimitiveDataFrameColumn
     /// </summary>
@@ -182,11 +70,15 @@ public PrimitiveColumnContainer(ReadOnlyMemory<byte> buffer, ReadOnlyMemory<byte
                 if (!buffer.IsEmpty)
                 {
                     // Create a new bitMap with all the bits up to length set
-                    var bitMap = new byte[bitMapBufferLength];
-                    bitMap.AsSpan().Fill(255);
+                    var bitMap = new DataFrameBuffer<byte>(bitMapBufferLength);
+                    bitMap.IncreaseSize(bitMapBufferLength);
+
+                    var span = bitMap.Span;
+                    span.Fill(255);
                     int lastByte = 1 << (length - (bitMapBufferLength - 1) * 8);
-                    bitMap[bitMapBufferLength - 1] = (byte)(lastByte - 1);
-                    nullDataFrameBuffer = new DataFrameBuffer<byte>(bitMap, bitMapBufferLength);
+                    span[bitMapBufferLength - 1] = (byte)(lastByte - 1);
+
+                    nullDataFrameBuffer = bitMap;
                 }
                 else
                 {
@@ -276,7 +168,7 @@ public void AppendMany(T? value, long count)
                 if (value.HasValue)
                 {
                     mutableLastBuffer.RawSpan.Slice(mutableLastBuffer.Length - allocatable, allocatable).Fill(value.Value);
-                    BitmapHelper.SetBits(lastNullBitMapBuffer.RawSpan, originalBufferLength, allocatable, true);
+                    BitUtility.SetBits(lastNullBitMapBuffer.RawSpan, originalBufferLength, allocatable, true);
                 }
 
                 remaining -= allocatable;
@@ -296,7 +188,7 @@ public void ApplyElementwise(Func<T?, long, T?> func)
                 for (int i = 0; i < mutableBuffer.Length; i++)
                 {
                     long curIndex = i + prevLength;
-                    bool isValid = BitmapHelper.IsValid(mutableNullBitMapBuffer, i);
+                    bool isValid = BitUtility.IsValid(mutableNullBitMapBuffer, i);
                     T? value = func(isValid ? mutableBuffer[i] : null, curIndex);
                     mutableBuffer[i] = value.GetValueOrDefault();
                     SetValidityBit(mutableNullBitMapBuffer, i, value != null);
@@ -319,7 +211,7 @@ public void Apply<TResult>(Func<T?, TResult?> func, PrimitiveColumnContainer<TRe
 
                 for (int i = 0; i < sourceBuffer.Length; i++)
                 {
-                    bool isValid = BitmapHelper.IsValid(sourceNullBitMap, i);
+                    bool isValid = BitUtility.IsValid(sourceNullBitMap, i);
                     TResult? value = func(isValid ? sourceBuffer[i] : null);
                     mutableResultBuffer[i] = value.GetValueOrDefault();
                     resultContainer.SetValidityBit(mutableResultNullBitMapBuffers, i, value != null);
@@ -335,7 +227,7 @@ private byte SetBit(byte curBitMap, int index, bool value)
             if (value)
             {
                 newBitMap = (byte)(curBitMap | (byte)(1 << (index & 7))); //bit hack for index % 8
-                if (BitmapHelper.IsBitClear(curBitMap, index) && index < Length && NullCount > 0)
+                if (BitUtility.IsBitClear(curBitMap, index) && index < Length && NullCount > 0)
                 {
                     // Old value was null.
                     NullCount--;
@@ -343,7 +235,7 @@ private byte SetBit(byte curBitMap, int index, bool value)
             }
             else
             {
-                if (BitmapHelper.IsBitSet(curBitMap, index) && index < Length)
+                if (BitUtility.IsBitSet(curBitMap, index) && index < Length)
                 {
                     // old value was NOT null and new value is null
                     NullCount++;
@@ -410,12 +302,13 @@ private bool GetValidityBit(long index)
             int bitMapBufferIndex = (int)((uint)index / 8);
             Debug.Assert(bitMapBuffer.Length > bitMapBufferIndex);
             byte curBitMap = bitMapBuffer[bitMapBufferIndex];
-            return BitmapHelper.IsBitSet(curBitMap, (int)index);
+            return BitUtility.IsBitSet(curBitMap, (int)index);
         }
 
-        public long Length;
+        public long Length { get; private set; }
+
+        public long NullCount { get; private set; }
 
-        public long NullCount;
         public int GetArrayContainingRowIndex(long rowIndex)
         {
             if (rowIndex >= Length)
@@ -567,7 +460,7 @@ public PrimitiveColumnContainer<T> Clone<U>(PrimitiveColumnContainer<U> mapIndic
                         spanIndex = buffer.Length - 1 - i;
 
                     long mapRowIndex = mapIndicesIntSpan.IsEmpty ? mapIndicesLongSpan[spanIndex] : mapIndicesIntSpan[spanIndex];
-                    bool mapRowIndexIsValid = BitmapHelper.IsValid(mapIndicesNullBitMapSpan, spanIndex);
+                    bool mapRowIndexIsValid = BitUtility.IsValid(mapIndicesNullBitMapSpan, spanIndex);
                     if (mapRowIndexIsValid && (mapRowIndex < minRange || mapRowIndex >= maxRange))
                     {
                         int bufferIndex = (int)(mapRowIndex / maxCapacity);
@@ -582,7 +475,7 @@ public PrimitiveColumnContainer<T> Clone<U>(PrimitiveColumnContainer<U> mapIndic
                     {
                         mapRowIndex -= minRange;
                         value = thisSpan[(int)mapRowIndex];
-                        isValid = BitmapHelper.IsValid(thisNullBitMapSpan, (int)mapRowIndex);
+                        isValid = BitUtility.IsValid(thisNullBitMapSpan, (int)mapRowIndex);
                     }
 
                     retSpan[i] = isValid ? value : default;
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationAPIs.ExplodedColumns.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationAPIs.ExplodedColumns.cs
index 25f36cfdf9..f879536391 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationAPIs.ExplodedColumns.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationAPIs.ExplodedColumns.cs
@@ -11,8732 +11,8755 @@
 
 namespace Microsoft.Data.Analysis
 {
+
     public partial class ByteDataFrameColumn
     {
         public Int32DataFrameColumn Add(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.AddImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.SubtractImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Divide(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.DivideImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.ModuloImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace: true);
         }
         public DecimalDataFrameColumn Add(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.AddImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.SubtractImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.MultiplyImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.DivideImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ModuloImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public DoubleDataFrameColumn Add(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.AddImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.SubtractImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.MultiplyImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.DivideImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ModuloImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public SingleDataFrameColumn Add(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public SingleDataFrameColumn Divide(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public Int32DataFrameColumn Add(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public Int32DataFrameColumn Divide(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public Int64DataFrameColumn Add(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.AddImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.SubtractImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public Int64DataFrameColumn Divide(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.DivideImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ModuloImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public Int32DataFrameColumn Add(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.AddImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.SubtractImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Divide(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.DivideImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.ModuloImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Add(Int16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.AddImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(Int16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.SubtractImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(Int16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Divide(Int16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.DivideImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(Int16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.ModuloImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace: true);
         }
         public UInt32DataFrameColumn Add(UInt32DataFrameColumn column)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.AddImplementation(column, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public UInt32DataFrameColumn Subtract(UInt32DataFrameColumn column)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.SubtractImplementation(column, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public UInt32DataFrameColumn Multiply(UInt32DataFrameColumn column)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.MultiplyImplementation(column, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public UInt32DataFrameColumn Divide(UInt32DataFrameColumn column)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.DivideImplementation(column, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public UInt32DataFrameColumn Modulo(UInt32DataFrameColumn column)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ModuloImplementation(column, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public UInt64DataFrameColumn Add(UInt64DataFrameColumn column)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.AddImplementation(column, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public UInt64DataFrameColumn Subtract(UInt64DataFrameColumn column)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.SubtractImplementation(column, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public UInt64DataFrameColumn Multiply(UInt64DataFrameColumn column)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.MultiplyImplementation(column, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public UInt64DataFrameColumn Divide(UInt64DataFrameColumn column)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.DivideImplementation(column, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public UInt64DataFrameColumn Modulo(UInt64DataFrameColumn column)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ModuloImplementation(column, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public Int32DataFrameColumn Add(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.AddImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.SubtractImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Divide(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.DivideImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.ModuloImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace: true);
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         public DecimalDataFrameColumn Add(ByteDataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return AddImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Subtract(ByteDataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return SubtractImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Multiply(ByteDataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return MultiplyImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Divide(ByteDataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return DivideImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Modulo(ByteDataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ModuloImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Add(DecimalDataFrameColumn column, bool inPlace = false)
         {
-            return AddImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, column, inPlace);
         }
         public DecimalDataFrameColumn Subtract(DecimalDataFrameColumn column, bool inPlace = false)
         {
-            return SubtractImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace);
         }
         public DecimalDataFrameColumn Multiply(DecimalDataFrameColumn column, bool inPlace = false)
         {
-            return MultiplyImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace);
         }
         public DecimalDataFrameColumn Divide(DecimalDataFrameColumn column, bool inPlace = false)
         {
-            return DivideImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, column, inPlace);
         }
         public DecimalDataFrameColumn Modulo(DecimalDataFrameColumn column, bool inPlace = false)
         {
-            return ModuloImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace);
         }
         public DecimalDataFrameColumn Add(Int32DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return AddImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Subtract(Int32DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return SubtractImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Multiply(Int32DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return MultiplyImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Divide(Int32DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return DivideImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Modulo(Int32DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ModuloImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Add(Int64DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return AddImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Subtract(Int64DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return SubtractImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Multiply(Int64DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return MultiplyImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Divide(Int64DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return DivideImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Modulo(Int64DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ModuloImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Add(SByteDataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return AddImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Subtract(SByteDataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return SubtractImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Multiply(SByteDataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return MultiplyImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Divide(SByteDataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return DivideImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Modulo(SByteDataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ModuloImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Add(Int16DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return AddImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Subtract(Int16DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return SubtractImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Multiply(Int16DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return MultiplyImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Divide(Int16DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return DivideImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Modulo(Int16DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ModuloImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Add(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return AddImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Subtract(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return SubtractImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Multiply(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return MultiplyImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Divide(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return DivideImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Modulo(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ModuloImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Add(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return AddImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Subtract(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return SubtractImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Multiply(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return MultiplyImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Divide(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return DivideImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Modulo(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ModuloImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Add(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return AddImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Subtract(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return SubtractImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Multiply(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return MultiplyImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Divide(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return DivideImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherdecimalColumn, inPlace);
         }
         public DecimalDataFrameColumn Modulo(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ModuloImplementation(otherdecimalColumn, inPlace);
+            var otherdecimalColumn = column.CloneAsDecimalColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherdecimalColumn, inPlace);
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         public DoubleDataFrameColumn Add(ByteDataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return AddImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Subtract(ByteDataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return SubtractImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Multiply(ByteDataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return MultiplyImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Divide(ByteDataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return DivideImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Modulo(ByteDataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ModuloImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Add(DoubleDataFrameColumn column, bool inPlace = false)
         {
-            return AddImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, column, inPlace);
         }
         public DoubleDataFrameColumn Subtract(DoubleDataFrameColumn column, bool inPlace = false)
         {
-            return SubtractImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace);
         }
         public DoubleDataFrameColumn Multiply(DoubleDataFrameColumn column, bool inPlace = false)
         {
-            return MultiplyImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace);
         }
         public DoubleDataFrameColumn Divide(DoubleDataFrameColumn column, bool inPlace = false)
         {
-            return DivideImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, column, inPlace);
         }
         public DoubleDataFrameColumn Modulo(DoubleDataFrameColumn column, bool inPlace = false)
         {
-            return ModuloImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace);
         }
         public DoubleDataFrameColumn Add(SingleDataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return AddImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Subtract(SingleDataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return SubtractImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Multiply(SingleDataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return MultiplyImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Divide(SingleDataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return DivideImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Modulo(SingleDataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ModuloImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Add(Int32DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return AddImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Subtract(Int32DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return SubtractImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Multiply(Int32DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return MultiplyImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Divide(Int32DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return DivideImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Modulo(Int32DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ModuloImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Add(Int64DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return AddImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Subtract(Int64DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return SubtractImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Multiply(Int64DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return MultiplyImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Divide(Int64DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return DivideImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Modulo(Int64DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ModuloImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Add(SByteDataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return AddImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Subtract(SByteDataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return SubtractImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Multiply(SByteDataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return MultiplyImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Divide(SByteDataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return DivideImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Modulo(SByteDataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ModuloImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Add(Int16DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return AddImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Subtract(Int16DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return SubtractImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Multiply(Int16DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return MultiplyImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Divide(Int16DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return DivideImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Modulo(Int16DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ModuloImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Add(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return AddImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Subtract(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return SubtractImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Multiply(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return MultiplyImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Divide(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return DivideImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Modulo(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ModuloImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Add(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return AddImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Subtract(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return SubtractImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Multiply(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return MultiplyImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Divide(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return DivideImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Modulo(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ModuloImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Add(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return AddImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Subtract(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return SubtractImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Multiply(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return MultiplyImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Divide(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return DivideImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherdoubleColumn, inPlace);
         }
         public DoubleDataFrameColumn Modulo(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ModuloImplementation(otherdoubleColumn, inPlace);
+            var otherdoubleColumn = column.CloneAsDoubleColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherdoubleColumn, inPlace);
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         public SingleDataFrameColumn Add(ByteDataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return AddImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Subtract(ByteDataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return SubtractImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Multiply(ByteDataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return MultiplyImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Divide(ByteDataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return DivideImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Modulo(ByteDataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ModuloImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherfloatColumn, inPlace);
         }
         public DoubleDataFrameColumn Add(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.AddImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.SubtractImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.MultiplyImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.DivideImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ModuloImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public SingleDataFrameColumn Add(SingleDataFrameColumn column, bool inPlace = false)
         {
-            return AddImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, column, inPlace);
         }
         public SingleDataFrameColumn Subtract(SingleDataFrameColumn column, bool inPlace = false)
         {
-            return SubtractImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace);
         }
         public SingleDataFrameColumn Multiply(SingleDataFrameColumn column, bool inPlace = false)
         {
-            return MultiplyImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace);
         }
         public SingleDataFrameColumn Divide(SingleDataFrameColumn column, bool inPlace = false)
         {
-            return DivideImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, column, inPlace);
         }
         public SingleDataFrameColumn Modulo(SingleDataFrameColumn column, bool inPlace = false)
         {
-            return ModuloImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace);
         }
         public SingleDataFrameColumn Add(Int32DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return AddImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Subtract(Int32DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return SubtractImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Multiply(Int32DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return MultiplyImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Divide(Int32DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return DivideImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Modulo(Int32DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ModuloImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Add(Int64DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return AddImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Subtract(Int64DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return SubtractImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Multiply(Int64DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return MultiplyImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Divide(Int64DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return DivideImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Modulo(Int64DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ModuloImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Add(SByteDataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return AddImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Subtract(SByteDataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return SubtractImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Multiply(SByteDataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return MultiplyImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Divide(SByteDataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return DivideImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Modulo(SByteDataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ModuloImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Add(Int16DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return AddImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Subtract(Int16DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return SubtractImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Multiply(Int16DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return MultiplyImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Divide(Int16DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return DivideImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Modulo(Int16DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ModuloImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Add(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return AddImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Subtract(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return SubtractImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Multiply(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return MultiplyImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Divide(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return DivideImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Modulo(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ModuloImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Add(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return AddImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Subtract(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return SubtractImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Multiply(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return MultiplyImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Divide(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return DivideImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Modulo(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ModuloImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Add(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return AddImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Add, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Subtract(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return SubtractImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Multiply(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return MultiplyImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Divide(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return DivideImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherfloatColumn, inPlace);
         }
         public SingleDataFrameColumn Modulo(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ModuloImplementation(otherfloatColumn, inPlace);
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherfloatColumn, inPlace);
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         public Int32DataFrameColumn Add(ByteDataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return AddImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace);
         }
         public Int32DataFrameColumn Subtract(ByteDataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return SubtractImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace);
         }
         public Int32DataFrameColumn Multiply(ByteDataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return MultiplyImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace);
         }
         public Int32DataFrameColumn Divide(ByteDataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return DivideImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace);
         }
         public Int32DataFrameColumn Modulo(ByteDataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ModuloImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace);
         }
         public DecimalDataFrameColumn Add(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.AddImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.SubtractImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.MultiplyImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.DivideImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ModuloImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public DoubleDataFrameColumn Add(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.AddImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.SubtractImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.MultiplyImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.DivideImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ModuloImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public SingleDataFrameColumn Add(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public SingleDataFrameColumn Divide(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public Int32DataFrameColumn Add(Int32DataFrameColumn column, bool inPlace = false)
         {
-            return AddImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, column, inPlace);
         }
         public Int32DataFrameColumn Subtract(Int32DataFrameColumn column, bool inPlace = false)
         {
-            return SubtractImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace);
         }
         public Int32DataFrameColumn Multiply(Int32DataFrameColumn column, bool inPlace = false)
         {
-            return MultiplyImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace);
         }
         public Int32DataFrameColumn Divide(Int32DataFrameColumn column, bool inPlace = false)
         {
-            return DivideImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, column, inPlace);
         }
         public Int32DataFrameColumn Modulo(Int32DataFrameColumn column, bool inPlace = false)
         {
-            return ModuloImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace);
         }
         public Int64DataFrameColumn Add(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.AddImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.SubtractImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public Int64DataFrameColumn Divide(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.DivideImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ModuloImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public Int32DataFrameColumn Add(SByteDataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return AddImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace);
         }
         public Int32DataFrameColumn Subtract(SByteDataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return SubtractImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace);
         }
         public Int32DataFrameColumn Multiply(SByteDataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return MultiplyImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace);
         }
         public Int32DataFrameColumn Divide(SByteDataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return DivideImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace);
         }
         public Int32DataFrameColumn Modulo(SByteDataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ModuloImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace);
         }
         public Int32DataFrameColumn Add(Int16DataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return AddImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace);
         }
         public Int32DataFrameColumn Subtract(Int16DataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return SubtractImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace);
         }
         public Int32DataFrameColumn Multiply(Int16DataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return MultiplyImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace);
         }
         public Int32DataFrameColumn Divide(Int16DataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return DivideImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace);
         }
         public Int32DataFrameColumn Modulo(Int16DataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ModuloImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace);
         }
         public Int64DataFrameColumn Add(UInt32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.AddImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(UInt32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.SubtractImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(UInt32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Divide(UInt32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.DivideImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(UInt32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.ModuloImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherlongColumn, inPlace: true);
         }
         public SingleDataFrameColumn Add(UInt64DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.AddImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(UInt64DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(UInt64DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Divide(UInt64DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(UInt64DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherfloatColumn, inPlace: true);
         }
         public Int32DataFrameColumn Add(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return AddImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace);
         }
         public Int32DataFrameColumn Subtract(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return SubtractImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace);
         }
         public Int32DataFrameColumn Multiply(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return MultiplyImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace);
         }
         public Int32DataFrameColumn Divide(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return DivideImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace);
         }
         public Int32DataFrameColumn Modulo(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ModuloImplementation(otherintColumn, inPlace);
+            var otherintColumn = column.CloneAsInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace);
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         public Int64DataFrameColumn Add(ByteDataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return AddImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Add, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Subtract(ByteDataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return SubtractImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Multiply(ByteDataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return MultiplyImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Divide(ByteDataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return DivideImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Modulo(ByteDataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ModuloImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherlongColumn, inPlace);
         }
         public DecimalDataFrameColumn Add(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.AddImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.SubtractImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.MultiplyImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.DivideImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ModuloImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public DoubleDataFrameColumn Add(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.AddImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.SubtractImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.MultiplyImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.DivideImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ModuloImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public SingleDataFrameColumn Add(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public SingleDataFrameColumn Divide(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public Int64DataFrameColumn Add(Int32DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return AddImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Add, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Subtract(Int32DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return SubtractImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Multiply(Int32DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return MultiplyImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Divide(Int32DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return DivideImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Modulo(Int32DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ModuloImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Add(Int64DataFrameColumn column, bool inPlace = false)
         {
-            return AddImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, column, inPlace);
         }
         public Int64DataFrameColumn Subtract(Int64DataFrameColumn column, bool inPlace = false)
         {
-            return SubtractImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace);
         }
         public Int64DataFrameColumn Multiply(Int64DataFrameColumn column, bool inPlace = false)
         {
-            return MultiplyImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace);
         }
         public Int64DataFrameColumn Divide(Int64DataFrameColumn column, bool inPlace = false)
         {
-            return DivideImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, column, inPlace);
         }
         public Int64DataFrameColumn Modulo(Int64DataFrameColumn column, bool inPlace = false)
         {
-            return ModuloImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace);
         }
         public Int64DataFrameColumn Add(SByteDataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return AddImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Add, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Subtract(SByteDataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return SubtractImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Multiply(SByteDataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return MultiplyImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Divide(SByteDataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return DivideImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Modulo(SByteDataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ModuloImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Add(Int16DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return AddImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Add, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Subtract(Int16DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return SubtractImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Multiply(Int16DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return MultiplyImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Divide(Int16DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return DivideImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Modulo(Int16DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ModuloImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Add(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return AddImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Add, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Subtract(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return SubtractImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Multiply(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return MultiplyImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Divide(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return DivideImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Modulo(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ModuloImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Add(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return AddImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Add, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Subtract(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return SubtractImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Multiply(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return MultiplyImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Divide(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return DivideImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherlongColumn, inPlace);
         }
         public Int64DataFrameColumn Modulo(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ModuloImplementation(otherlongColumn, inPlace);
+            var otherlongColumn = column.CloneAsInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherlongColumn, inPlace);
         }
     }
+
     public partial class SByteDataFrameColumn
     {
         public Int32DataFrameColumn Add(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.AddImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.SubtractImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Divide(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.DivideImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.ModuloImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace: true);
         }
         public DecimalDataFrameColumn Add(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.AddImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.SubtractImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.MultiplyImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.DivideImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ModuloImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public DoubleDataFrameColumn Add(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.AddImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.SubtractImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.MultiplyImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.DivideImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ModuloImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public SingleDataFrameColumn Add(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public SingleDataFrameColumn Divide(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public Int32DataFrameColumn Add(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public Int32DataFrameColumn Divide(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public Int64DataFrameColumn Add(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.AddImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.SubtractImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public Int64DataFrameColumn Divide(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.DivideImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ModuloImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public Int32DataFrameColumn Add(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.AddImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.SubtractImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Divide(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.DivideImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.ModuloImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Add(Int16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.AddImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(Int16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.SubtractImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(Int16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Divide(Int16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.DivideImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(Int16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.ModuloImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace: true);
         }
         public Int64DataFrameColumn Add(UInt32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.AddImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(UInt32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.SubtractImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(UInt32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Divide(UInt32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.DivideImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(UInt32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.ModuloImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherlongColumn, inPlace: true);
         }
         public SingleDataFrameColumn Add(UInt64DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.AddImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(UInt64DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(UInt64DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Divide(UInt64DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(UInt64DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherfloatColumn, inPlace: true);
         }
         public Int32DataFrameColumn Add(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.AddImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.SubtractImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Divide(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.DivideImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.ModuloImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace: true);
         }
     }
+
     public partial class Int16DataFrameColumn
     {
         public Int32DataFrameColumn Add(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.AddImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.SubtractImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Divide(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.DivideImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.ModuloImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace: true);
         }
         public DecimalDataFrameColumn Add(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.AddImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.SubtractImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.MultiplyImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.DivideImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ModuloImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public DoubleDataFrameColumn Add(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.AddImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.SubtractImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.MultiplyImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.DivideImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ModuloImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public SingleDataFrameColumn Add(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public SingleDataFrameColumn Divide(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public Int32DataFrameColumn Add(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public Int32DataFrameColumn Divide(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public Int64DataFrameColumn Add(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.AddImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.SubtractImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public Int64DataFrameColumn Divide(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.DivideImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ModuloImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public Int32DataFrameColumn Add(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.AddImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.SubtractImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Divide(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.DivideImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.ModuloImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Add(Int16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.AddImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(Int16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.SubtractImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(Int16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Divide(Int16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.DivideImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(Int16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.ModuloImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace: true);
         }
         public Int64DataFrameColumn Add(UInt32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.AddImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(UInt32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.SubtractImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(UInt32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Divide(UInt32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.DivideImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(UInt32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.ModuloImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherlongColumn, inPlace: true);
         }
         public SingleDataFrameColumn Add(UInt64DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.AddImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(UInt64DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(UInt64DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Divide(UInt64DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(UInt64DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherfloatColumn, inPlace: true);
         }
         public Int32DataFrameColumn Add(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.AddImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.SubtractImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Divide(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.DivideImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.ModuloImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace: true);
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         public UInt32DataFrameColumn Add(ByteDataFrameColumn column, bool inPlace = false)
         {
-            UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return AddImplementation(otheruintColumn, inPlace);
+            var otheruintColumn = column.CloneAsUInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Add, otheruintColumn, inPlace);
         }
         public UInt32DataFrameColumn Subtract(ByteDataFrameColumn column, bool inPlace = false)
         {
-            UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return SubtractImplementation(otheruintColumn, inPlace);
+            var otheruintColumn = column.CloneAsUInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otheruintColumn, inPlace);
         }
         public UInt32DataFrameColumn Multiply(ByteDataFrameColumn column, bool inPlace = false)
         {
-            UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return MultiplyImplementation(otheruintColumn, inPlace);
+            var otheruintColumn = column.CloneAsUInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otheruintColumn, inPlace);
         }
         public UInt32DataFrameColumn Divide(ByteDataFrameColumn column, bool inPlace = false)
         {
-            UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return DivideImplementation(otheruintColumn, inPlace);
+            var otheruintColumn = column.CloneAsUInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Divide, otheruintColumn, inPlace);
         }
         public UInt32DataFrameColumn Modulo(ByteDataFrameColumn column, bool inPlace = false)
         {
-            UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ModuloImplementation(otheruintColumn, inPlace);
+            var otheruintColumn = column.CloneAsUInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otheruintColumn, inPlace);
         }
         public DecimalDataFrameColumn Add(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.AddImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.SubtractImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.MultiplyImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.DivideImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ModuloImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public DoubleDataFrameColumn Add(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.AddImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.SubtractImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.MultiplyImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.DivideImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ModuloImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public SingleDataFrameColumn Add(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public SingleDataFrameColumn Divide(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public Int64DataFrameColumn Add(Int32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.AddImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(Int32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.SubtractImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(Int32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Divide(Int32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.DivideImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(Int32DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.ModuloImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Add(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.AddImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.SubtractImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public Int64DataFrameColumn Divide(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.DivideImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ModuloImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public Int64DataFrameColumn Add(SByteDataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.AddImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(SByteDataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.SubtractImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(SByteDataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Divide(SByteDataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.DivideImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(SByteDataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.ModuloImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Add(Int16DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.AddImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(Int16DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.SubtractImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(Int16DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Divide(Int16DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.DivideImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, otherlongColumn, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(Int16DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return longColumn.ModuloImplementation(otherlongColumn, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            var otherlongColumn = column.CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherlongColumn, inPlace: true);
         }
         public UInt32DataFrameColumn Add(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            return AddImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, column, inPlace);
         }
         public UInt32DataFrameColumn Subtract(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            return SubtractImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace);
         }
         public UInt32DataFrameColumn Multiply(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            return MultiplyImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace);
         }
         public UInt32DataFrameColumn Divide(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            return DivideImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, column, inPlace);
         }
         public UInt32DataFrameColumn Modulo(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            return ModuloImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace);
         }
         public UInt64DataFrameColumn Add(UInt64DataFrameColumn column)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.AddImplementation(column, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public UInt64DataFrameColumn Subtract(UInt64DataFrameColumn column)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.SubtractImplementation(column, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public UInt64DataFrameColumn Multiply(UInt64DataFrameColumn column)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.MultiplyImplementation(column, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public UInt64DataFrameColumn Divide(UInt64DataFrameColumn column)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.DivideImplementation(column, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public UInt64DataFrameColumn Modulo(UInt64DataFrameColumn column)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ModuloImplementation(column, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public UInt32DataFrameColumn Add(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return AddImplementation(otheruintColumn, inPlace);
+            var otheruintColumn = column.CloneAsUInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Add, otheruintColumn, inPlace);
         }
         public UInt32DataFrameColumn Subtract(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return SubtractImplementation(otheruintColumn, inPlace);
+            var otheruintColumn = column.CloneAsUInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otheruintColumn, inPlace);
         }
         public UInt32DataFrameColumn Multiply(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return MultiplyImplementation(otheruintColumn, inPlace);
+            var otheruintColumn = column.CloneAsUInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otheruintColumn, inPlace);
         }
         public UInt32DataFrameColumn Divide(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return DivideImplementation(otheruintColumn, inPlace);
+            var otheruintColumn = column.CloneAsUInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Divide, otheruintColumn, inPlace);
         }
         public UInt32DataFrameColumn Modulo(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ModuloImplementation(otheruintColumn, inPlace);
+            var otheruintColumn = column.CloneAsUInt32Column();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otheruintColumn, inPlace);
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         public UInt64DataFrameColumn Add(ByteDataFrameColumn column, bool inPlace = false)
         {
-            UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return AddImplementation(otherulongColumn, inPlace);
+            var otherulongColumn = column.CloneAsUInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Add, otherulongColumn, inPlace);
         }
         public UInt64DataFrameColumn Subtract(ByteDataFrameColumn column, bool inPlace = false)
         {
-            UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return SubtractImplementation(otherulongColumn, inPlace);
+            var otherulongColumn = column.CloneAsUInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherulongColumn, inPlace);
         }
         public UInt64DataFrameColumn Multiply(ByteDataFrameColumn column, bool inPlace = false)
         {
-            UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return MultiplyImplementation(otherulongColumn, inPlace);
+            var otherulongColumn = column.CloneAsUInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherulongColumn, inPlace);
         }
         public UInt64DataFrameColumn Divide(ByteDataFrameColumn column, bool inPlace = false)
         {
-            UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return DivideImplementation(otherulongColumn, inPlace);
+            var otherulongColumn = column.CloneAsUInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherulongColumn, inPlace);
         }
         public UInt64DataFrameColumn Modulo(ByteDataFrameColumn column, bool inPlace = false)
         {
-            UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ModuloImplementation(otherulongColumn, inPlace);
+            var otherulongColumn = column.CloneAsUInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherulongColumn, inPlace);
         }
         public DecimalDataFrameColumn Add(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.AddImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.SubtractImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.MultiplyImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.DivideImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ModuloImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public DoubleDataFrameColumn Add(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.AddImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.SubtractImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.MultiplyImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.DivideImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ModuloImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public SingleDataFrameColumn Add(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public SingleDataFrameColumn Divide(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public SingleDataFrameColumn Add(Int32DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.AddImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(Int32DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(Int32DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Divide(Int32DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(Int32DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Add(SByteDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.AddImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(SByteDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(SByteDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Divide(SByteDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(SByteDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Add(Int16DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.AddImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(Int16DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(Int16DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Divide(Int16DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, otherfloatColumn, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(Int16DataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(otherfloatColumn, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            var otherfloatColumn = column.CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherfloatColumn, inPlace: true);
         }
         public UInt64DataFrameColumn Add(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return AddImplementation(otherulongColumn, inPlace);
+            var otherulongColumn = column.CloneAsUInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Add, otherulongColumn, inPlace);
         }
         public UInt64DataFrameColumn Subtract(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return SubtractImplementation(otherulongColumn, inPlace);
+            var otherulongColumn = column.CloneAsUInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherulongColumn, inPlace);
         }
         public UInt64DataFrameColumn Multiply(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return MultiplyImplementation(otherulongColumn, inPlace);
+            var otherulongColumn = column.CloneAsUInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherulongColumn, inPlace);
         }
         public UInt64DataFrameColumn Divide(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return DivideImplementation(otherulongColumn, inPlace);
+            var otherulongColumn = column.CloneAsUInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherulongColumn, inPlace);
         }
         public UInt64DataFrameColumn Modulo(UInt32DataFrameColumn column, bool inPlace = false)
         {
-            UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ModuloImplementation(otherulongColumn, inPlace);
+            var otherulongColumn = column.CloneAsUInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherulongColumn, inPlace);
         }
         public UInt64DataFrameColumn Add(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            return AddImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, column, inPlace);
         }
         public UInt64DataFrameColumn Subtract(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            return SubtractImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace);
         }
         public UInt64DataFrameColumn Multiply(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            return MultiplyImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace);
         }
         public UInt64DataFrameColumn Divide(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            return DivideImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, column, inPlace);
         }
         public UInt64DataFrameColumn Modulo(UInt64DataFrameColumn column, bool inPlace = false)
         {
-            return ModuloImplementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace);
         }
         public UInt64DataFrameColumn Add(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return AddImplementation(otherulongColumn, inPlace);
+            var otherulongColumn = column.CloneAsUInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Add, otherulongColumn, inPlace);
         }
         public UInt64DataFrameColumn Subtract(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return SubtractImplementation(otherulongColumn, inPlace);
+            var otherulongColumn = column.CloneAsUInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Subtract, otherulongColumn, inPlace);
         }
         public UInt64DataFrameColumn Multiply(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return MultiplyImplementation(otherulongColumn, inPlace);
+            var otherulongColumn = column.CloneAsUInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Multiply, otherulongColumn, inPlace);
         }
         public UInt64DataFrameColumn Divide(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return DivideImplementation(otherulongColumn, inPlace);
+            var otherulongColumn = column.CloneAsUInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Divide, otherulongColumn, inPlace);
         }
         public UInt64DataFrameColumn Modulo(UInt16DataFrameColumn column, bool inPlace = false)
         {
-            UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ModuloImplementation(otherulongColumn, inPlace);
+            var otherulongColumn = column.CloneAsUInt64Column();
+            return HandleOperationImplementation(BinaryOperation.Modulo, otherulongColumn, inPlace);
         }
     }
+
     public partial class UInt16DataFrameColumn
     {
         public Int32DataFrameColumn Add(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.AddImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.SubtractImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Divide(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.DivideImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(ByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.ModuloImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace: true);
         }
         public DecimalDataFrameColumn Add(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.AddImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.SubtractImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.MultiplyImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.DivideImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ModuloImplementation(column, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public DoubleDataFrameColumn Add(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.AddImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.SubtractImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.MultiplyImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.DivideImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(DoubleDataFrameColumn column)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ModuloImplementation(column, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public SingleDataFrameColumn Add(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public SingleDataFrameColumn Divide(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(SingleDataFrameColumn column)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(column, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public Int32DataFrameColumn Add(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public Int32DataFrameColumn Divide(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(Int32DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(column, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public Int64DataFrameColumn Add(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.AddImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.SubtractImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public Int64DataFrameColumn Divide(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.DivideImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(Int64DataFrameColumn column)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ModuloImplementation(column, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public Int32DataFrameColumn Add(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.AddImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.SubtractImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Divide(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.DivideImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.ModuloImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Add(Int16DataFrameColumn column)
-        {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.AddImplementation(otherintColumn, inPlace: true);
+        {
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(Int16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.SubtractImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(Int16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Divide(Int16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.DivideImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(Int16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.ModuloImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace: true);
         }
         public UInt32DataFrameColumn Add(UInt32DataFrameColumn column)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.AddImplementation(column, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public UInt32DataFrameColumn Subtract(UInt32DataFrameColumn column)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.SubtractImplementation(column, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public UInt32DataFrameColumn Multiply(UInt32DataFrameColumn column)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.MultiplyImplementation(column, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public UInt32DataFrameColumn Divide(UInt32DataFrameColumn column)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.DivideImplementation(column, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public UInt32DataFrameColumn Modulo(UInt32DataFrameColumn column)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ModuloImplementation(column, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public UInt64DataFrameColumn Add(UInt64DataFrameColumn column)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.AddImplementation(column, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Add, column, inPlace: true);
         }
         public UInt64DataFrameColumn Subtract(UInt64DataFrameColumn column)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.SubtractImplementation(column, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Subtract, column, inPlace: true);
         }
         public UInt64DataFrameColumn Multiply(UInt64DataFrameColumn column)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.MultiplyImplementation(column, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Multiply, column, inPlace: true);
         }
         public UInt64DataFrameColumn Divide(UInt64DataFrameColumn column)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.DivideImplementation(column, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Divide, column, inPlace: true);
         }
         public UInt64DataFrameColumn Modulo(UInt64DataFrameColumn column)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ModuloImplementation(column, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Modulo, column, inPlace: true);
         }
         public Int32DataFrameColumn Add(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.AddImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.SubtractImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Divide(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.DivideImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, otherintColumn, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(UInt16DataFrameColumn column)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return intColumn.ModuloImplementation(otherintColumn, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            var otherintColumn = column.CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, otherintColumn, inPlace: true);
         }
     }
+
     public partial class ByteDataFrameColumn
     {
         public Int32DataFrameColumn Add(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn Add(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.AddImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseAdd(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseAddImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.SubtractImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseSubtract(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.MultiplyImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseMultiply(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.DivideImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseDivide(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseDivideImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ModuloImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseModulo(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseModuloImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn Add(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.AddImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseAdd(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseAddImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.SubtractImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.MultiplyImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.DivideImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseDivide(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseDivideImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ModuloImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseModulo(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseModuloImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseAddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseDivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.AddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseAddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.SubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.DivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseDivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public UInt32DataFrameColumn Add(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.AddImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseAdd(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ReverseAddImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public UInt32DataFrameColumn Subtract(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.SubtractImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseSubtract(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public UInt32DataFrameColumn Multiply(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.MultiplyImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseMultiply(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public UInt32DataFrameColumn Divide(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.DivideImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseDivide(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ReverseDivideImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public UInt32DataFrameColumn Modulo(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ModuloImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseModulo(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ReverseModuloImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public UInt64DataFrameColumn Add(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.AddImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseAdd(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ReverseAddImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public UInt64DataFrameColumn Subtract(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.SubtractImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseSubtract(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public UInt64DataFrameColumn Multiply(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.MultiplyImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseMultiply(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public UInt64DataFrameColumn Divide(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.DivideImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseDivide(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ReverseDivideImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public UInt64DataFrameColumn Modulo(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ModuloImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseModulo(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ReverseModuloImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         public DecimalDataFrameColumn Add(byte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseAdd(byte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Subtract(byte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseSubtract(byte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Multiply(byte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseMultiply(byte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Divide(byte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseDivide(byte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Modulo(byte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseModulo(byte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(decimal value, bool inPlace = false)
         {
-            return AddImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
         }
         public DecimalDataFrameColumn ReverseAdd(decimal value, bool inPlace = false)
         {
-            return ReverseAddImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
         }
         public DecimalDataFrameColumn Subtract(decimal value, bool inPlace = false)
         {
-            return SubtractImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
         }
         public DecimalDataFrameColumn ReverseSubtract(decimal value, bool inPlace = false)
         {
-            return ReverseSubtractImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
         }
         public DecimalDataFrameColumn Multiply(decimal value, bool inPlace = false)
         {
-            return MultiplyImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
         }
         public DecimalDataFrameColumn ReverseMultiply(decimal value, bool inPlace = false)
         {
-            return ReverseMultiplyImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
         }
         public DecimalDataFrameColumn Divide(decimal value, bool inPlace = false)
         {
-            return DivideImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
         }
         public DecimalDataFrameColumn ReverseDivide(decimal value, bool inPlace = false)
         {
-            return ReverseDivideImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
         }
         public DecimalDataFrameColumn Modulo(decimal value, bool inPlace = false)
         {
-            return ModuloImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
         }
         public DecimalDataFrameColumn ReverseModulo(decimal value, bool inPlace = false)
         {
-            return ReverseModuloImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
         }
         public DecimalDataFrameColumn Add(int value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseAdd(int value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Subtract(int value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseSubtract(int value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Multiply(int value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseMultiply(int value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Divide(int value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseDivide(int value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Modulo(int value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseModulo(int value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(long value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseAdd(long value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Subtract(long value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseSubtract(long value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Multiply(long value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseMultiply(long value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Divide(long value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseDivide(long value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Modulo(long value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseModulo(long value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(sbyte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseAdd(sbyte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Subtract(sbyte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseSubtract(sbyte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Multiply(sbyte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseMultiply(sbyte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Divide(sbyte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseDivide(sbyte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Modulo(sbyte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseModulo(sbyte value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(short value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseAdd(short value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Subtract(short value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseSubtract(short value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Multiply(short value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseMultiply(short value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Divide(short value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseDivide(short value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Modulo(short value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseModulo(short value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(uint value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseAdd(uint value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Subtract(uint value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseSubtract(uint value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Multiply(uint value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseMultiply(uint value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Divide(uint value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseDivide(uint value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Modulo(uint value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseModulo(uint value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(ulong value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseAdd(ulong value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Subtract(ulong value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseSubtract(ulong value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Multiply(ulong value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseMultiply(ulong value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Divide(ulong value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseDivide(ulong value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Modulo(ulong value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseModulo(ulong value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(ushort value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseAdd(ushort value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Subtract(ushort value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseSubtract(ushort value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Multiply(ushort value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseMultiply(ushort value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Divide(ushort value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseDivide(ushort value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Modulo(ushort value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseModulo(ushort value, bool inPlace = false)
         {
-            decimal convertedValue = (decimal)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (decimal)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         public DoubleDataFrameColumn Add(byte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(byte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Subtract(byte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(byte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Multiply(byte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(byte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Divide(byte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(byte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Modulo(byte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(byte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Add(double value, bool inPlace = false)
         {
-            return AddImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(double value, bool inPlace = false)
         {
-            return ReverseAddImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
         }
         public DoubleDataFrameColumn Subtract(double value, bool inPlace = false)
         {
-            return SubtractImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value, bool inPlace = false)
         {
-            return ReverseSubtractImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
         }
         public DoubleDataFrameColumn Multiply(double value, bool inPlace = false)
         {
-            return MultiplyImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value, bool inPlace = false)
         {
-            return ReverseMultiplyImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
         }
         public DoubleDataFrameColumn Divide(double value, bool inPlace = false)
         {
-            return DivideImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(double value, bool inPlace = false)
         {
-            return ReverseDivideImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
         }
         public DoubleDataFrameColumn Modulo(double value, bool inPlace = false)
         {
-            return ModuloImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(double value, bool inPlace = false)
         {
-            return ReverseModuloImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
         }
         public DoubleDataFrameColumn Add(float value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(float value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Subtract(float value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(float value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Multiply(float value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(float value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Divide(float value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(float value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Modulo(float value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(float value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Add(int value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(int value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Subtract(int value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(int value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Multiply(int value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(int value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Divide(int value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(int value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Modulo(int value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(int value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Add(long value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(long value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Subtract(long value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(long value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Multiply(long value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(long value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Divide(long value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(long value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Modulo(long value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(long value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Add(sbyte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(sbyte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Subtract(sbyte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(sbyte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Multiply(sbyte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(sbyte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Divide(sbyte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(sbyte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Modulo(sbyte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(sbyte value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Add(short value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(short value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Subtract(short value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(short value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Multiply(short value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(short value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Divide(short value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(short value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Modulo(short value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(short value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Add(uint value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(uint value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Subtract(uint value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(uint value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Multiply(uint value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(uint value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Divide(uint value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(uint value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Modulo(uint value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(uint value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Add(ulong value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(ulong value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Subtract(ulong value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(ulong value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Multiply(ulong value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(ulong value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Divide(ulong value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(ulong value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Modulo(ulong value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(ulong value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Add(ushort value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(ushort value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Subtract(ushort value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(ushort value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Multiply(ushort value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(ushort value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Divide(ushort value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(ushort value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Modulo(ushort value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(ushort value, bool inPlace = false)
         {
-            double convertedValue = (double)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (double)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         public SingleDataFrameColumn Add(byte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseAdd(byte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Subtract(byte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseSubtract(byte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Multiply(byte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseMultiply(byte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Divide(byte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseDivide(byte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Modulo(byte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseModulo(byte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Add(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.AddImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseAdd(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseAddImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.SubtractImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.MultiplyImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.DivideImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseDivide(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseDivideImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ModuloImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseModulo(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseModuloImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(float value, bool inPlace = false)
         {
-            return AddImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
         }
         public SingleDataFrameColumn ReverseAdd(float value, bool inPlace = false)
         {
-            return ReverseAddImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
         }
         public SingleDataFrameColumn Subtract(float value, bool inPlace = false)
         {
-            return SubtractImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
         }
         public SingleDataFrameColumn ReverseSubtract(float value, bool inPlace = false)
         {
-            return ReverseSubtractImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
         }
         public SingleDataFrameColumn Multiply(float value, bool inPlace = false)
         {
-            return MultiplyImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
         }
         public SingleDataFrameColumn ReverseMultiply(float value, bool inPlace = false)
         {
-            return ReverseMultiplyImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
         }
         public SingleDataFrameColumn Divide(float value, bool inPlace = false)
         {
-            return DivideImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
         }
         public SingleDataFrameColumn ReverseDivide(float value, bool inPlace = false)
         {
-            return ReverseDivideImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
         }
         public SingleDataFrameColumn Modulo(float value, bool inPlace = false)
         {
-            return ModuloImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
         }
         public SingleDataFrameColumn ReverseModulo(float value, bool inPlace = false)
         {
-            return ReverseModuloImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
         }
         public SingleDataFrameColumn Add(int value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseAdd(int value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Subtract(int value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseSubtract(int value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Multiply(int value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseMultiply(int value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Divide(int value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseDivide(int value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Modulo(int value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseModulo(int value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Add(long value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseAdd(long value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Subtract(long value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseSubtract(long value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Multiply(long value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseMultiply(long value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Divide(long value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseDivide(long value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Modulo(long value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseModulo(long value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Add(sbyte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseAdd(sbyte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Subtract(sbyte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseSubtract(sbyte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Multiply(sbyte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseMultiply(sbyte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Divide(sbyte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseDivide(sbyte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Modulo(sbyte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseModulo(sbyte value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Add(short value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseAdd(short value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Subtract(short value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseSubtract(short value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Multiply(short value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseMultiply(short value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Divide(short value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseDivide(short value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Modulo(short value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseModulo(short value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Add(uint value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseAdd(uint value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Subtract(uint value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseSubtract(uint value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Multiply(uint value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseMultiply(uint value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Divide(uint value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseDivide(uint value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Modulo(uint value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseModulo(uint value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Add(ulong value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseAdd(ulong value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Subtract(ulong value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseSubtract(ulong value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Multiply(ulong value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseMultiply(ulong value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Divide(ulong value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseDivide(ulong value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Modulo(ulong value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseModulo(ulong value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Add(ushort value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseAdd(ushort value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Subtract(ushort value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseSubtract(ushort value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Multiply(ushort value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseMultiply(ushort value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Divide(ushort value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseDivide(ushort value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Modulo(ushort value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseModulo(ushort value, bool inPlace = false)
         {
-            float convertedValue = (float)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (float)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         public Int32DataFrameColumn Add(byte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseAdd(byte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Subtract(byte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseSubtract(byte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Multiply(byte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseMultiply(byte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Divide(byte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseDivide(byte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Modulo(byte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseModulo(byte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.AddImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseAdd(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseAddImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.SubtractImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseSubtract(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.MultiplyImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseMultiply(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.DivideImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseDivide(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseDivideImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ModuloImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseModulo(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseModuloImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn Add(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.AddImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseAdd(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseAddImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.SubtractImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.MultiplyImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.DivideImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseDivide(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseDivideImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ModuloImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseModulo(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseModuloImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseAddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseDivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(int value, bool inPlace = false)
         {
-            return AddImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
         }
         public Int32DataFrameColumn ReverseAdd(int value, bool inPlace = false)
         {
-            return ReverseAddImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
         }
         public Int32DataFrameColumn Subtract(int value, bool inPlace = false)
         {
-            return SubtractImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
         }
         public Int32DataFrameColumn ReverseSubtract(int value, bool inPlace = false)
         {
-            return ReverseSubtractImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
         }
         public Int32DataFrameColumn Multiply(int value, bool inPlace = false)
         {
-            return MultiplyImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
         }
         public Int32DataFrameColumn ReverseMultiply(int value, bool inPlace = false)
         {
-            return ReverseMultiplyImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
         }
         public Int32DataFrameColumn Divide(int value, bool inPlace = false)
         {
-            return DivideImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
         }
         public Int32DataFrameColumn ReverseDivide(int value, bool inPlace = false)
         {
-            return ReverseDivideImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
         }
         public Int32DataFrameColumn Modulo(int value, bool inPlace = false)
         {
-            return ModuloImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
         }
         public Int32DataFrameColumn ReverseModulo(int value, bool inPlace = false)
         {
-            return ReverseModuloImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
         }
         public Int64DataFrameColumn Add(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.AddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseAddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.SubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.DivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseDivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(sbyte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseAdd(sbyte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Subtract(sbyte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseSubtract(sbyte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Multiply(sbyte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseMultiply(sbyte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Divide(sbyte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseDivide(sbyte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Modulo(sbyte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseModulo(sbyte value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Add(short value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseAdd(short value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Subtract(short value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseSubtract(short value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Multiply(short value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseMultiply(short value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Divide(short value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseDivide(short value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Modulo(short value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseModulo(short value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Add(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.AddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseAddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.SubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.DivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseDivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseAddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseDivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(ushort value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseAdd(ushort value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Subtract(ushort value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseSubtract(ushort value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Multiply(ushort value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseMultiply(ushort value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Divide(ushort value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseDivide(ushort value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Modulo(ushort value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseModulo(ushort value, bool inPlace = false)
         {
-            int convertedValue = (int)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (int)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         public Int64DataFrameColumn Add(byte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseAdd(byte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Subtract(byte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseSubtract(byte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Multiply(byte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseMultiply(byte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Divide(byte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseDivide(byte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Modulo(byte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseModulo(byte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.AddImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseAdd(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseAddImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.SubtractImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseSubtract(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.MultiplyImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseMultiply(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.DivideImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseDivide(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseDivideImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ModuloImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseModulo(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseModuloImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn Add(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.AddImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseAdd(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseAddImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.SubtractImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.MultiplyImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.DivideImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseDivide(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseDivideImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ModuloImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseModulo(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseModuloImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseAddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseDivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(int value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseAdd(int value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Subtract(int value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseSubtract(int value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Multiply(int value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseMultiply(int value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Divide(int value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseDivide(int value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Modulo(int value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseModulo(int value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Add(long value, bool inPlace = false)
         {
-            return AddImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
         }
         public Int64DataFrameColumn ReverseAdd(long value, bool inPlace = false)
         {
-            return ReverseAddImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
         }
         public Int64DataFrameColumn Subtract(long value, bool inPlace = false)
         {
-            return SubtractImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
         }
         public Int64DataFrameColumn ReverseSubtract(long value, bool inPlace = false)
         {
-            return ReverseSubtractImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
         }
         public Int64DataFrameColumn Multiply(long value, bool inPlace = false)
         {
-            return MultiplyImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
         }
         public Int64DataFrameColumn ReverseMultiply(long value, bool inPlace = false)
         {
-            return ReverseMultiplyImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
         }
         public Int64DataFrameColumn Divide(long value, bool inPlace = false)
         {
-            return DivideImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
         }
         public Int64DataFrameColumn ReverseDivide(long value, bool inPlace = false)
         {
-            return ReverseDivideImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
         }
         public Int64DataFrameColumn Modulo(long value, bool inPlace = false)
         {
-            return ModuloImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
         }
         public Int64DataFrameColumn ReverseModulo(long value, bool inPlace = false)
         {
-            return ReverseModuloImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
         }
         public Int64DataFrameColumn Add(sbyte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseAdd(sbyte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Subtract(sbyte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseSubtract(sbyte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Multiply(sbyte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseMultiply(sbyte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Divide(sbyte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseDivide(sbyte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Modulo(sbyte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseModulo(sbyte value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Add(short value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseAdd(short value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Subtract(short value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseSubtract(short value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Multiply(short value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseMultiply(short value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Divide(short value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseDivide(short value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Modulo(short value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseModulo(short value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Add(uint value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseAdd(uint value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Subtract(uint value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseSubtract(uint value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Multiply(uint value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseMultiply(uint value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Divide(uint value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseDivide(uint value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Modulo(uint value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseModulo(uint value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Add(ushort value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseAdd(ushort value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Subtract(ushort value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseSubtract(ushort value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Multiply(ushort value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseMultiply(ushort value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Divide(ushort value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseDivide(ushort value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Modulo(ushort value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseModulo(ushort value, bool inPlace = false)
         {
-            long convertedValue = (long)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (long)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
     }
+
     public partial class SByteDataFrameColumn
     {
         public Int32DataFrameColumn Add(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn Add(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.AddImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseAdd(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseAddImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.SubtractImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseSubtract(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.MultiplyImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseMultiply(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.DivideImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseDivide(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseDivideImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ModuloImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseModulo(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseModuloImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn Add(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.AddImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseAdd(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseAddImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.SubtractImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.MultiplyImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.DivideImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseDivide(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseDivideImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ModuloImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseModulo(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseModuloImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseAddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseDivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.AddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseAddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.SubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.DivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseDivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.AddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseAddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.SubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.DivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseDivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseAddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseDivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
     }
+
     public partial class Int16DataFrameColumn
     {
         public Int32DataFrameColumn Add(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn Add(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.AddImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseAdd(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseAddImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.SubtractImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseSubtract(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.MultiplyImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseMultiply(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.DivideImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseDivide(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseDivideImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ModuloImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseModulo(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseModuloImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn Add(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.AddImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseAdd(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseAddImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.SubtractImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.MultiplyImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.DivideImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseDivide(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseDivideImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ModuloImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseModulo(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseModuloImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseAddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseDivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.AddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseAddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.SubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.DivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseDivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.AddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseAddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.SubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.DivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseDivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(uint value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseAddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseDivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(ulong value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         public UInt32DataFrameColumn Add(byte value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseAdd(byte value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn Subtract(byte value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseSubtract(byte value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn Multiply(byte value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseMultiply(byte value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn Divide(byte value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseDivide(byte value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn Modulo(byte value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseModulo(byte value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.AddImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseAdd(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseAddImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.SubtractImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseSubtract(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.MultiplyImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseMultiply(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.DivideImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseDivide(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseDivideImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ModuloImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseModulo(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseModuloImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn Add(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.AddImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseAdd(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseAddImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.SubtractImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.MultiplyImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.DivideImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseDivide(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseDivideImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ModuloImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseModulo(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseModuloImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseAddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseDivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(int value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.AddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(int value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseAddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(int value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.SubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(int value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(int value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(int value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(int value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.DivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(int value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseDivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(int value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(int value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.AddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseAddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.SubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.DivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseDivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(sbyte value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.AddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(sbyte value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseAddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(sbyte value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.SubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(sbyte value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(sbyte value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(sbyte value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(sbyte value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.DivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(sbyte value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseDivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(sbyte value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(sbyte value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(short value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.AddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(short value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseAddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(short value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.SubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(short value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(short value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(short value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(short value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.DivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(short value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseDivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(short value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(short value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public UInt32DataFrameColumn Add(uint value, bool inPlace = false)
         {
-            return AddImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
         }
         public UInt32DataFrameColumn ReverseAdd(uint value, bool inPlace = false)
         {
-            return ReverseAddImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
         }
         public UInt32DataFrameColumn Subtract(uint value, bool inPlace = false)
         {
-            return SubtractImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
         }
         public UInt32DataFrameColumn ReverseSubtract(uint value, bool inPlace = false)
         {
-            return ReverseSubtractImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
         }
         public UInt32DataFrameColumn Multiply(uint value, bool inPlace = false)
         {
-            return MultiplyImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
         }
         public UInt32DataFrameColumn ReverseMultiply(uint value, bool inPlace = false)
         {
-            return ReverseMultiplyImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
         }
         public UInt32DataFrameColumn Divide(uint value, bool inPlace = false)
         {
-            return DivideImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
         }
         public UInt32DataFrameColumn ReverseDivide(uint value, bool inPlace = false)
         {
-            return ReverseDivideImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
         }
         public UInt32DataFrameColumn Modulo(uint value, bool inPlace = false)
         {
-            return ModuloImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
         }
         public UInt32DataFrameColumn ReverseModulo(uint value, bool inPlace = false)
         {
-            return ReverseModuloImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
         }
         public UInt64DataFrameColumn Add(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.AddImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseAdd(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ReverseAddImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public UInt64DataFrameColumn Subtract(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.SubtractImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseSubtract(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public UInt64DataFrameColumn Multiply(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.MultiplyImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseMultiply(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public UInt64DataFrameColumn Divide(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.DivideImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseDivide(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ReverseDivideImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public UInt64DataFrameColumn Modulo(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ModuloImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseModulo(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ReverseModuloImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public UInt32DataFrameColumn Add(ushort value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseAdd(ushort value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn Subtract(ushort value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseSubtract(ushort value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn Multiply(ushort value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseMultiply(ushort value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn Divide(ushort value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseDivide(ushort value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn Modulo(ushort value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseModulo(ushort value, bool inPlace = false)
         {
-            uint convertedValue = (uint)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (uint)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         public UInt64DataFrameColumn Add(byte value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseAdd(byte value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Subtract(byte value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseSubtract(byte value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Multiply(byte value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseMultiply(byte value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Divide(byte value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseDivide(byte value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Modulo(byte value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseModulo(byte value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.AddImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseAdd(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseAddImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.SubtractImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseSubtract(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.MultiplyImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseMultiply(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.DivideImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseDivide(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseDivideImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ModuloImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseModulo(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseModuloImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn Add(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.AddImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseAdd(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseAddImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.SubtractImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.MultiplyImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.DivideImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseDivide(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseDivideImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ModuloImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseModulo(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseModuloImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseAddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseDivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(int value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(int value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseAddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(int value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(int value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(int value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(int value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(int value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(int value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseDivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(int value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(int value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(sbyte value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(sbyte value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseAddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(sbyte value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(sbyte value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(sbyte value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(sbyte value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(sbyte value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(sbyte value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseDivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(sbyte value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(sbyte value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(short value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(short value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseAddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(short value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(short value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(short value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(short value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(short value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(short value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseDivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(short value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(short value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public UInt64DataFrameColumn Add(uint value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseAdd(uint value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Subtract(uint value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseSubtract(uint value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Multiply(uint value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseMultiply(uint value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Divide(uint value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseDivide(uint value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Modulo(uint value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseModulo(uint value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Add(ulong value, bool inPlace = false)
         {
-            return AddImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
         }
         public UInt64DataFrameColumn ReverseAdd(ulong value, bool inPlace = false)
         {
-            return ReverseAddImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
         }
         public UInt64DataFrameColumn Subtract(ulong value, bool inPlace = false)
         {
-            return SubtractImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
         }
         public UInt64DataFrameColumn ReverseSubtract(ulong value, bool inPlace = false)
         {
-            return ReverseSubtractImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
         }
         public UInt64DataFrameColumn Multiply(ulong value, bool inPlace = false)
         {
-            return MultiplyImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
         }
         public UInt64DataFrameColumn ReverseMultiply(ulong value, bool inPlace = false)
         {
-            return ReverseMultiplyImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
         }
         public UInt64DataFrameColumn Divide(ulong value, bool inPlace = false)
         {
-            return DivideImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
         }
         public UInt64DataFrameColumn ReverseDivide(ulong value, bool inPlace = false)
         {
-            return ReverseDivideImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
         }
         public UInt64DataFrameColumn Modulo(ulong value, bool inPlace = false)
         {
-            return ModuloImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
         }
         public UInt64DataFrameColumn ReverseModulo(ulong value, bool inPlace = false)
         {
-            return ReverseModuloImplementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
         }
         public UInt64DataFrameColumn Add(ushort value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return AddImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseAdd(ushort value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return ReverseAddImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Subtract(ushort value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return SubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseSubtract(ushort value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return ReverseSubtractImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Multiply(ushort value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return MultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseMultiply(ushort value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return ReverseMultiplyImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Divide(ushort value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return DivideImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseDivide(ushort value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return ReverseDivideImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Modulo(ushort value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return ModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseModulo(ushort value, bool inPlace = false)
         {
-            ulong convertedValue = (ulong)value;
-            return ReverseModuloImplementation(convertedValue, inPlace);
+            var convertedValue = (ulong)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
         }
     }
+
     public partial class UInt16DataFrameColumn
     {
         public Int32DataFrameColumn Add(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(byte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn Add(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.AddImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseAdd(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseAddImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.SubtractImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseSubtract(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.MultiplyImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseMultiply(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.DivideImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseDivide(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseDivideImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ModuloImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseModulo(decimal value)
         {
-            DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ReverseModuloImplementation(value, inPlace: true);
+            var decimalColumn = CloneAsDecimalColumn();
+            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn Add(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.AddImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseAdd(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseAddImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.SubtractImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.MultiplyImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.DivideImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseDivide(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseDivideImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ModuloImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseModulo(double value)
         {
-            DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ReverseModuloImplementation(value, inPlace: true);
+            var doubleColumn = CloneAsDoubleColumn();
+            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.AddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseAddImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.SubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.MultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.DivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseDivideImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(float value)
         {
-            SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ReverseModuloImplementation(value, inPlace: true);
+            var floatColumn = CloneAsSingleColumn();
+            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(int value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.AddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseAddImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.SubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.MultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.DivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseDivideImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(long value)
         {
-            Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ReverseModuloImplementation(value, inPlace: true);
+            var longColumn = CloneAsInt64Column();
+            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(sbyte value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(short value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public UInt32DataFrameColumn Add(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.AddImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseAdd(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ReverseAddImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public UInt32DataFrameColumn Subtract(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.SubtractImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseSubtract(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public UInt32DataFrameColumn Multiply(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.MultiplyImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseMultiply(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public UInt32DataFrameColumn Divide(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.DivideImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseDivide(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ReverseDivideImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public UInt32DataFrameColumn Modulo(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ModuloImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseModulo(uint value)
         {
-            UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ReverseModuloImplementation(value, inPlace: true);
+            var uintColumn = CloneAsUInt32Column();
+            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public UInt64DataFrameColumn Add(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.AddImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseAdd(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ReverseAddImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public UInt64DataFrameColumn Subtract(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.SubtractImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseSubtract(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public UInt64DataFrameColumn Multiply(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.MultiplyImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseMultiply(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public UInt64DataFrameColumn Divide(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.DivideImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseDivide(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ReverseDivideImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public UInt64DataFrameColumn Modulo(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ModuloImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseModulo(ulong value)
         {
-            UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ReverseModuloImplementation(value, inPlace: true);
+            var ulongColumn = CloneAsUInt64Column();
+            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.AddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseAddImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.SubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseSubtractImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.MultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseMultiplyImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.DivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseDivideImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(ushort value)
         {
-            Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ReverseModuloImplementation(value, inPlace: true);
+            var intColumn = CloneAsInt32Column();
+            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
         }
     }
+
     public partial class BooleanDataFrameColumn
     {
         public BooleanDataFrameColumn And(BooleanDataFrameColumn column, bool inPlace = false)
@@ -8746,19 +8769,21 @@ public BooleanDataFrameColumn And(BooleanDataFrameColumn column, bool inPlace =
                 throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
             }
             BooleanDataFrameColumn retColumn = inPlace ? this : CloneAsBooleanColumn();
-            retColumn.ColumnContainer.And(column.ColumnContainer);
+            retColumn.ColumnContainer.HandleOperation(BinaryOperation.And, column.ColumnContainer);
             return retColumn;
         }
     }
+
     public partial class BooleanDataFrameColumn
     {
         public new BooleanDataFrameColumn And(bool value, bool inPlace = false)
         {
             BooleanDataFrameColumn retColumn = inPlace ? this : CloneAsBooleanColumn();
-            retColumn.ColumnContainer.And(value);
+            retColumn.ColumnContainer.HandleOperation(BinaryScalarOperation.And, value);
             return retColumn;
         }
     }
+
     public partial class BooleanDataFrameColumn
     {
         public BooleanDataFrameColumn Or(BooleanDataFrameColumn column, bool inPlace = false)
@@ -8768,19 +8793,21 @@ public BooleanDataFrameColumn Or(BooleanDataFrameColumn column, bool inPlace = f
                 throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
             }
             BooleanDataFrameColumn retColumn = inPlace ? this : CloneAsBooleanColumn();
-            retColumn.ColumnContainer.Or(column.ColumnContainer);
+            retColumn.ColumnContainer.HandleOperation(BinaryOperation.Or, column.ColumnContainer);
             return retColumn;
         }
     }
+
     public partial class BooleanDataFrameColumn
     {
         public new BooleanDataFrameColumn Or(bool value, bool inPlace = false)
         {
             BooleanDataFrameColumn retColumn = inPlace ? this : CloneAsBooleanColumn();
-            retColumn.ColumnContainer.Or(value);
+            retColumn.ColumnContainer.HandleOperation(BinaryScalarOperation.Or, value);
             return retColumn;
         }
     }
+
     public partial class BooleanDataFrameColumn
     {
         public BooleanDataFrameColumn Xor(BooleanDataFrameColumn column, bool inPlace = false)
@@ -8790,6963 +8817,6991 @@ public BooleanDataFrameColumn Xor(BooleanDataFrameColumn column, bool inPlace =
                 throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
             }
             BooleanDataFrameColumn retColumn = inPlace ? this : CloneAsBooleanColumn();
-            retColumn.ColumnContainer.Xor(column.ColumnContainer);
+            retColumn.ColumnContainer.HandleOperation(BinaryOperation.Xor, column.ColumnContainer);
             return retColumn;
         }
     }
+
     public partial class BooleanDataFrameColumn
     {
         public new BooleanDataFrameColumn Xor(bool value, bool inPlace = false)
         {
             BooleanDataFrameColumn retColumn = inPlace ? this : CloneAsBooleanColumn();
-            retColumn.ColumnContainer.Xor(value);
+            retColumn.ColumnContainer.HandleOperation(BinaryScalarOperation.Xor, value);
             return retColumn;
         }
     }
 
+
     public partial class BooleanDataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(BooleanDataFrameColumn column)
         {
-            return ElementwiseEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(BooleanDataFrameColumn column)
         {
-            return ElementwiseNotEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(BooleanDataFrameColumn column)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(BooleanDataFrameColumn column)
         {
-            return ElementwiseLessThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(BooleanDataFrameColumn column)
         {
-            return ElementwiseGreaterThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(BooleanDataFrameColumn column)
         {
-            return ElementwiseLessThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
     }
+
     public partial class ByteDataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(ByteDataFrameColumn column)
         {
-            return ElementwiseEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ByteDataFrameColumn column)
         {
-            return ElementwiseNotEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ByteDataFrameColumn column)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ByteDataFrameColumn column)
         {
-            return ElementwiseLessThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ByteDataFrameColumn column)
         {
-            return ElementwiseGreaterThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ByteDataFrameColumn column)
         {
-            return ElementwiseLessThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseEqualsImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseNotEqualsImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseEqualsImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseNotEqualsImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseEqualsImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseNotEqualsImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseEqualsImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseNotEqualsImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseGreaterThanImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseLessThanImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseEqualsImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseNotEqualsImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SByteDataFrameColumn column)
         {
             ByteDataFrameColumn otherbyteColumn = column.CloneAsByteColumn();
-            return ElementwiseEqualsImplementation(otherbyteColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherbyteColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SByteDataFrameColumn column)
         {
             ByteDataFrameColumn otherbyteColumn = column.CloneAsByteColumn();
-            return ElementwiseNotEqualsImplementation(otherbyteColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherbyteColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SByteDataFrameColumn column)
         {
             ByteDataFrameColumn otherbyteColumn = column.CloneAsByteColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherbyteColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherbyteColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SByteDataFrameColumn column)
         {
             ByteDataFrameColumn otherbyteColumn = column.CloneAsByteColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherbyteColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherbyteColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SByteDataFrameColumn column)
         {
             ByteDataFrameColumn otherbyteColumn = column.CloneAsByteColumn();
-            return ElementwiseGreaterThanImplementation(otherbyteColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherbyteColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SByteDataFrameColumn column)
         {
             ByteDataFrameColumn otherbyteColumn = column.CloneAsByteColumn();
-            return ElementwiseLessThanImplementation(otherbyteColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherbyteColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int16DataFrameColumn column)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseEqualsImplementation(column);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int16DataFrameColumn column)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseNotEqualsImplementation(column);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int16DataFrameColumn column)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int16DataFrameColumn column)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int16DataFrameColumn column)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseGreaterThanImplementation(column);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int16DataFrameColumn column)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseLessThanImplementation(column);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseEqualsImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseNotEqualsImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseGreaterThanImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseLessThanImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseEqualsImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseNotEqualsImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt16DataFrameColumn column)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseEqualsImplementation(column);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt16DataFrameColumn column)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseNotEqualsImplementation(column);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt16DataFrameColumn column)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt16DataFrameColumn column)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt16DataFrameColumn column)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseGreaterThanImplementation(column);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt16DataFrameColumn column)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseLessThanImplementation(column);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(ByteDataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseEqualsImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ByteDataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseNotEqualsImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ByteDataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ByteDataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ByteDataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseGreaterThanImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ByteDataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseLessThanImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(DecimalDataFrameColumn column)
         {
-            return ElementwiseEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DecimalDataFrameColumn column)
         {
-            return ElementwiseNotEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DecimalDataFrameColumn column)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DecimalDataFrameColumn column)
         {
-            return ElementwiseLessThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DecimalDataFrameColumn column)
         {
-            return ElementwiseGreaterThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DecimalDataFrameColumn column)
         {
-            return ElementwiseLessThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int32DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseEqualsImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int32DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseNotEqualsImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int32DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int32DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int32DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseGreaterThanImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int32DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseLessThanImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int64DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseEqualsImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int64DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseNotEqualsImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int64DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int64DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int64DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseGreaterThanImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int64DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseLessThanImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SByteDataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseEqualsImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SByteDataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseNotEqualsImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SByteDataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SByteDataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SByteDataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseGreaterThanImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SByteDataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseLessThanImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int16DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseEqualsImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int16DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseNotEqualsImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int16DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int16DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int16DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseGreaterThanImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int16DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseLessThanImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt32DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseEqualsImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt32DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseNotEqualsImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt32DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt32DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt32DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseGreaterThanImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt32DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseLessThanImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt64DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseEqualsImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt64DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseNotEqualsImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt64DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt64DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt64DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseGreaterThanImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt64DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseLessThanImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt16DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseEqualsImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt16DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseNotEqualsImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt16DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt16DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt16DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseGreaterThanImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdecimalColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt16DataFrameColumn column)
         {
             DecimalDataFrameColumn otherdecimalColumn = column.CloneAsDecimalColumn();
-            return ElementwiseLessThanImplementation(otherdecimalColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdecimalColumn);
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(ByteDataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseEqualsImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ByteDataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseNotEqualsImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ByteDataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ByteDataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ByteDataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseGreaterThanImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ByteDataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseLessThanImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(DoubleDataFrameColumn column)
         {
-            return ElementwiseEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DoubleDataFrameColumn column)
         {
-            return ElementwiseNotEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DoubleDataFrameColumn column)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DoubleDataFrameColumn column)
         {
-            return ElementwiseLessThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DoubleDataFrameColumn column)
         {
-            return ElementwiseGreaterThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DoubleDataFrameColumn column)
         {
-            return ElementwiseLessThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SingleDataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseEqualsImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SingleDataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseNotEqualsImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SingleDataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SingleDataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SingleDataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseGreaterThanImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SingleDataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseLessThanImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int32DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseEqualsImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int32DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseNotEqualsImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int32DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int32DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int32DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseGreaterThanImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int32DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseLessThanImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int64DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseEqualsImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int64DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseNotEqualsImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int64DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int64DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int64DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseGreaterThanImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int64DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseLessThanImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SByteDataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseEqualsImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SByteDataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseNotEqualsImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SByteDataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SByteDataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SByteDataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseGreaterThanImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SByteDataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseLessThanImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int16DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseEqualsImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int16DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseNotEqualsImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int16DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int16DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int16DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseGreaterThanImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int16DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseLessThanImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt32DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseEqualsImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt32DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseNotEqualsImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt32DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt32DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt32DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseGreaterThanImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt32DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseLessThanImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt64DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseEqualsImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt64DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseNotEqualsImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt64DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt64DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt64DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseGreaterThanImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt64DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseLessThanImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt16DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseEqualsImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt16DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseNotEqualsImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt16DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt16DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt16DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseGreaterThanImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdoubleColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt16DataFrameColumn column)
         {
             DoubleDataFrameColumn otherdoubleColumn = column.CloneAsDoubleColumn();
-            return ElementwiseLessThanImplementation(otherdoubleColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdoubleColumn);
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(ByteDataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseEqualsImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ByteDataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseNotEqualsImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ByteDataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ByteDataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ByteDataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseGreaterThanImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ByteDataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseLessThanImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseEqualsImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseNotEqualsImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SingleDataFrameColumn column)
         {
-            return ElementwiseEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SingleDataFrameColumn column)
         {
-            return ElementwiseNotEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SingleDataFrameColumn column)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SingleDataFrameColumn column)
         {
-            return ElementwiseLessThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SingleDataFrameColumn column)
         {
-            return ElementwiseGreaterThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SingleDataFrameColumn column)
         {
-            return ElementwiseLessThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int32DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseEqualsImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int32DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseNotEqualsImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int32DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int32DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int32DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseGreaterThanImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int32DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseLessThanImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int64DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseEqualsImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int64DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseNotEqualsImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int64DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int64DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int64DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseGreaterThanImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int64DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseLessThanImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SByteDataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseEqualsImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SByteDataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseNotEqualsImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SByteDataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SByteDataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SByteDataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseGreaterThanImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SByteDataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseLessThanImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int16DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseEqualsImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int16DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseNotEqualsImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int16DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int16DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int16DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseGreaterThanImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int16DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseLessThanImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt32DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseEqualsImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt32DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseNotEqualsImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt32DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt32DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt32DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseGreaterThanImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt32DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseLessThanImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt64DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseEqualsImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt64DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseNotEqualsImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt64DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt64DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt64DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseGreaterThanImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt64DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseLessThanImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt16DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseEqualsImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt16DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseNotEqualsImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt16DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt16DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseLessThanOrEqualImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt16DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseGreaterThanImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherfloatColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt16DataFrameColumn column)
         {
             SingleDataFrameColumn otherfloatColumn = column.CloneAsSingleColumn();
-            return ElementwiseLessThanImplementation(otherfloatColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherfloatColumn);
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(ByteDataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseEqualsImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ByteDataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseNotEqualsImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ByteDataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ByteDataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseLessThanOrEqualImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ByteDataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseGreaterThanImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ByteDataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseLessThanImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseEqualsImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseNotEqualsImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseEqualsImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseNotEqualsImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseEqualsImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseNotEqualsImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int32DataFrameColumn column)
         {
-            return ElementwiseEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int32DataFrameColumn column)
         {
-            return ElementwiseNotEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int32DataFrameColumn column)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int32DataFrameColumn column)
         {
-            return ElementwiseLessThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int32DataFrameColumn column)
         {
-            return ElementwiseGreaterThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int32DataFrameColumn column)
         {
-            return ElementwiseLessThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseEqualsImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseNotEqualsImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SByteDataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseEqualsImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SByteDataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseNotEqualsImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SByteDataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SByteDataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseLessThanOrEqualImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SByteDataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseGreaterThanImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SByteDataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseLessThanImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int16DataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseEqualsImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int16DataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseNotEqualsImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int16DataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int16DataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseLessThanOrEqualImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int16DataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseGreaterThanImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int16DataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseLessThanImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt32DataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseEqualsImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt32DataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseNotEqualsImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt32DataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt32DataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseLessThanOrEqualImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt32DataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseGreaterThanImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt32DataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseLessThanImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseEqualsImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseNotEqualsImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt16DataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseEqualsImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt16DataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseNotEqualsImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt16DataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt16DataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseLessThanOrEqualImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt16DataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseGreaterThanImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt16DataFrameColumn column)
         {
             Int32DataFrameColumn otherintColumn = column.CloneAsInt32Column();
-            return ElementwiseLessThanImplementation(otherintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherintColumn);
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(ByteDataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseEqualsImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ByteDataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseNotEqualsImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ByteDataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ByteDataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseLessThanOrEqualImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ByteDataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseGreaterThanImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ByteDataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseLessThanImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseEqualsImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseNotEqualsImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseEqualsImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseNotEqualsImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseEqualsImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseNotEqualsImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int32DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseEqualsImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int32DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseNotEqualsImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int32DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int32DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseLessThanOrEqualImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int32DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseGreaterThanImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int32DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseLessThanImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int64DataFrameColumn column)
         {
-            return ElementwiseEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int64DataFrameColumn column)
         {
-            return ElementwiseNotEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int64DataFrameColumn column)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int64DataFrameColumn column)
         {
-            return ElementwiseLessThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int64DataFrameColumn column)
         {
-            return ElementwiseGreaterThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int64DataFrameColumn column)
         {
-            return ElementwiseLessThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SByteDataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseEqualsImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SByteDataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseNotEqualsImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SByteDataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SByteDataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseLessThanOrEqualImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SByteDataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseGreaterThanImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SByteDataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseLessThanImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int16DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseEqualsImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int16DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseNotEqualsImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int16DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int16DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseLessThanOrEqualImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int16DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseGreaterThanImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int16DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseLessThanImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt32DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseEqualsImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt32DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseNotEqualsImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt32DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt32DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseLessThanOrEqualImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt32DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseGreaterThanImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt32DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseLessThanImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt16DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseEqualsImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt16DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseNotEqualsImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt16DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt16DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseLessThanOrEqualImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt16DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseGreaterThanImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherlongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt16DataFrameColumn column)
         {
             Int64DataFrameColumn otherlongColumn = column.CloneAsInt64Column();
-            return ElementwiseLessThanImplementation(otherlongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherlongColumn);
         }
     }
+
     public partial class SByteDataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(ByteDataFrameColumn column)
         {
             SByteDataFrameColumn othersbyteColumn = column.CloneAsSByteColumn();
-            return ElementwiseEqualsImplementation(othersbyteColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, othersbyteColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ByteDataFrameColumn column)
         {
             SByteDataFrameColumn othersbyteColumn = column.CloneAsSByteColumn();
-            return ElementwiseNotEqualsImplementation(othersbyteColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, othersbyteColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ByteDataFrameColumn column)
         {
             SByteDataFrameColumn othersbyteColumn = column.CloneAsSByteColumn();
-            return ElementwiseGreaterThanOrEqualImplementation(othersbyteColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, othersbyteColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ByteDataFrameColumn column)
         {
             SByteDataFrameColumn othersbyteColumn = column.CloneAsSByteColumn();
-            return ElementwiseLessThanOrEqualImplementation(othersbyteColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, othersbyteColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ByteDataFrameColumn column)
         {
             SByteDataFrameColumn othersbyteColumn = column.CloneAsSByteColumn();
-            return ElementwiseGreaterThanImplementation(othersbyteColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, othersbyteColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ByteDataFrameColumn column)
         {
             SByteDataFrameColumn othersbyteColumn = column.CloneAsSByteColumn();
-            return ElementwiseLessThanImplementation(othersbyteColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, othersbyteColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseEqualsImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseNotEqualsImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseEqualsImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseNotEqualsImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseEqualsImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseNotEqualsImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseEqualsImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseNotEqualsImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseGreaterThanImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseLessThanImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseEqualsImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseNotEqualsImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SByteDataFrameColumn column)
         {
-            return ElementwiseEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SByteDataFrameColumn column)
         {
-            return ElementwiseNotEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SByteDataFrameColumn column)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SByteDataFrameColumn column)
         {
-            return ElementwiseLessThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SByteDataFrameColumn column)
         {
-            return ElementwiseGreaterThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SByteDataFrameColumn column)
         {
-            return ElementwiseLessThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int16DataFrameColumn column)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseEqualsImplementation(column);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int16DataFrameColumn column)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseNotEqualsImplementation(column);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int16DataFrameColumn column)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int16DataFrameColumn column)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int16DataFrameColumn column)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseGreaterThanImplementation(column);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int16DataFrameColumn column)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseLessThanImplementation(column);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseEqualsImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseNotEqualsImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseGreaterThanImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseLessThanImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseEqualsImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseNotEqualsImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt16DataFrameColumn column)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseEqualsImplementation(column);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt16DataFrameColumn column)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseNotEqualsImplementation(column);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt16DataFrameColumn column)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt16DataFrameColumn column)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt16DataFrameColumn column)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseGreaterThanImplementation(column);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt16DataFrameColumn column)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseLessThanImplementation(column);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
     }
+
     public partial class Int16DataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(ByteDataFrameColumn column)
         {
             Int16DataFrameColumn othershortColumn = column.CloneAsInt16Column();
-            return ElementwiseEqualsImplementation(othershortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, othershortColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ByteDataFrameColumn column)
         {
             Int16DataFrameColumn othershortColumn = column.CloneAsInt16Column();
-            return ElementwiseNotEqualsImplementation(othershortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, othershortColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ByteDataFrameColumn column)
         {
             Int16DataFrameColumn othershortColumn = column.CloneAsInt16Column();
-            return ElementwiseGreaterThanOrEqualImplementation(othershortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, othershortColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ByteDataFrameColumn column)
         {
             Int16DataFrameColumn othershortColumn = column.CloneAsInt16Column();
-            return ElementwiseLessThanOrEqualImplementation(othershortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, othershortColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ByteDataFrameColumn column)
         {
             Int16DataFrameColumn othershortColumn = column.CloneAsInt16Column();
-            return ElementwiseGreaterThanImplementation(othershortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, othershortColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ByteDataFrameColumn column)
         {
             Int16DataFrameColumn othershortColumn = column.CloneAsInt16Column();
-            return ElementwiseLessThanImplementation(othershortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, othershortColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseEqualsImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseNotEqualsImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseEqualsImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseNotEqualsImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseEqualsImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseNotEqualsImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseEqualsImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseNotEqualsImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseGreaterThanImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseLessThanImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseEqualsImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseNotEqualsImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SByteDataFrameColumn column)
         {
             Int16DataFrameColumn othershortColumn = column.CloneAsInt16Column();
-            return ElementwiseEqualsImplementation(othershortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, othershortColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SByteDataFrameColumn column)
         {
             Int16DataFrameColumn othershortColumn = column.CloneAsInt16Column();
-            return ElementwiseNotEqualsImplementation(othershortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, othershortColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SByteDataFrameColumn column)
         {
             Int16DataFrameColumn othershortColumn = column.CloneAsInt16Column();
-            return ElementwiseGreaterThanOrEqualImplementation(othershortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, othershortColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SByteDataFrameColumn column)
         {
             Int16DataFrameColumn othershortColumn = column.CloneAsInt16Column();
-            return ElementwiseLessThanOrEqualImplementation(othershortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, othershortColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SByteDataFrameColumn column)
         {
             Int16DataFrameColumn othershortColumn = column.CloneAsInt16Column();
-            return ElementwiseGreaterThanImplementation(othershortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, othershortColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SByteDataFrameColumn column)
         {
             Int16DataFrameColumn othershortColumn = column.CloneAsInt16Column();
-            return ElementwiseLessThanImplementation(othershortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, othershortColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int16DataFrameColumn column)
         {
-            return ElementwiseEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int16DataFrameColumn column)
         {
-            return ElementwiseNotEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int16DataFrameColumn column)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int16DataFrameColumn column)
         {
-            return ElementwiseLessThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int16DataFrameColumn column)
         {
-            return ElementwiseGreaterThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int16DataFrameColumn column)
         {
-            return ElementwiseLessThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseEqualsImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseNotEqualsImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseGreaterThanImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseLessThanImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseEqualsImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseNotEqualsImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt16DataFrameColumn column)
         {
             Int16DataFrameColumn othershortColumn = column.CloneAsInt16Column();
-            return ElementwiseEqualsImplementation(othershortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, othershortColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt16DataFrameColumn column)
         {
             Int16DataFrameColumn othershortColumn = column.CloneAsInt16Column();
-            return ElementwiseNotEqualsImplementation(othershortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, othershortColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt16DataFrameColumn column)
         {
             Int16DataFrameColumn othershortColumn = column.CloneAsInt16Column();
-            return ElementwiseGreaterThanOrEqualImplementation(othershortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, othershortColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt16DataFrameColumn column)
         {
             Int16DataFrameColumn othershortColumn = column.CloneAsInt16Column();
-            return ElementwiseLessThanOrEqualImplementation(othershortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, othershortColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt16DataFrameColumn column)
         {
             Int16DataFrameColumn othershortColumn = column.CloneAsInt16Column();
-            return ElementwiseGreaterThanImplementation(othershortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, othershortColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt16DataFrameColumn column)
         {
             Int16DataFrameColumn othershortColumn = column.CloneAsInt16Column();
-            return ElementwiseLessThanImplementation(othershortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, othershortColumn);
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(ByteDataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseEqualsImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ByteDataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseNotEqualsImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ByteDataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ByteDataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseLessThanOrEqualImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ByteDataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseGreaterThanImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ByteDataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseLessThanImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseEqualsImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseNotEqualsImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseEqualsImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseNotEqualsImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseEqualsImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseNotEqualsImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int32DataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseEqualsImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int32DataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseNotEqualsImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int32DataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int32DataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseLessThanOrEqualImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int32DataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseGreaterThanImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int32DataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseLessThanImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseEqualsImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseNotEqualsImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SByteDataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseEqualsImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SByteDataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseNotEqualsImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SByteDataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SByteDataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseLessThanOrEqualImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SByteDataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseGreaterThanImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SByteDataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseLessThanImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int16DataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseEqualsImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int16DataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseNotEqualsImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int16DataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int16DataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseLessThanOrEqualImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int16DataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseGreaterThanImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int16DataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseLessThanImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt32DataFrameColumn column)
         {
-            return ElementwiseEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt32DataFrameColumn column)
         {
-            return ElementwiseNotEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt32DataFrameColumn column)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt32DataFrameColumn column)
         {
-            return ElementwiseLessThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt32DataFrameColumn column)
         {
-            return ElementwiseGreaterThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt32DataFrameColumn column)
         {
-            return ElementwiseLessThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseEqualsImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseNotEqualsImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt16DataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseEqualsImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt16DataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseNotEqualsImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt16DataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt16DataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseLessThanOrEqualImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt16DataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseGreaterThanImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otheruintColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt16DataFrameColumn column)
         {
             UInt32DataFrameColumn otheruintColumn = column.CloneAsUInt32Column();
-            return ElementwiseLessThanImplementation(otheruintColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otheruintColumn);
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(ByteDataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseEqualsImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ByteDataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseNotEqualsImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ByteDataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ByteDataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseLessThanOrEqualImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ByteDataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseGreaterThanImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ByteDataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseLessThanImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseEqualsImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseNotEqualsImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseEqualsImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseNotEqualsImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseEqualsImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseNotEqualsImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int32DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseEqualsImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int32DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseNotEqualsImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int32DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int32DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseLessThanOrEqualImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int32DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseGreaterThanImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int32DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseLessThanImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SByteDataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseEqualsImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SByteDataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseNotEqualsImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SByteDataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SByteDataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseLessThanOrEqualImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SByteDataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseGreaterThanImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SByteDataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseLessThanImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int16DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseEqualsImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int16DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseNotEqualsImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int16DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int16DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseLessThanOrEqualImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int16DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseGreaterThanImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int16DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseLessThanImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt32DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseEqualsImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt32DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseNotEqualsImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt32DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt32DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseLessThanOrEqualImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt32DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseGreaterThanImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt32DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseLessThanImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt64DataFrameColumn column)
         {
-            return ElementwiseEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt64DataFrameColumn column)
         {
-            return ElementwiseNotEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt64DataFrameColumn column)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt64DataFrameColumn column)
         {
-            return ElementwiseLessThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt64DataFrameColumn column)
         {
-            return ElementwiseGreaterThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt64DataFrameColumn column)
         {
-            return ElementwiseLessThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt16DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseEqualsImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt16DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseNotEqualsImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt16DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt16DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseLessThanOrEqualImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt16DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseGreaterThanImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherulongColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt16DataFrameColumn column)
         {
             UInt64DataFrameColumn otherulongColumn = column.CloneAsUInt64Column();
-            return ElementwiseLessThanImplementation(otherulongColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherulongColumn);
         }
     }
+
     public partial class UInt16DataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(ByteDataFrameColumn column)
         {
             UInt16DataFrameColumn otherushortColumn = column.CloneAsUInt16Column();
-            return ElementwiseEqualsImplementation(otherushortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherushortColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ByteDataFrameColumn column)
         {
             UInt16DataFrameColumn otherushortColumn = column.CloneAsUInt16Column();
-            return ElementwiseNotEqualsImplementation(otherushortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherushortColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ByteDataFrameColumn column)
         {
             UInt16DataFrameColumn otherushortColumn = column.CloneAsUInt16Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherushortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherushortColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ByteDataFrameColumn column)
         {
             UInt16DataFrameColumn otherushortColumn = column.CloneAsUInt16Column();
-            return ElementwiseLessThanOrEqualImplementation(otherushortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherushortColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ByteDataFrameColumn column)
         {
             UInt16DataFrameColumn otherushortColumn = column.CloneAsUInt16Column();
-            return ElementwiseGreaterThanImplementation(otherushortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherushortColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ByteDataFrameColumn column)
         {
             UInt16DataFrameColumn otherushortColumn = column.CloneAsUInt16Column();
-            return ElementwiseLessThanImplementation(otherushortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherushortColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseEqualsImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseNotEqualsImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DecimalDataFrameColumn column)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanImplementation(column);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseEqualsImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseNotEqualsImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DoubleDataFrameColumn column)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanImplementation(column);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseEqualsImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseNotEqualsImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SingleDataFrameColumn column)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanImplementation(column);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseEqualsImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseNotEqualsImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseGreaterThanImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int32DataFrameColumn column)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseLessThanImplementation(column);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseEqualsImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseNotEqualsImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int64DataFrameColumn column)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanImplementation(column);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(SByteDataFrameColumn column)
         {
             UInt16DataFrameColumn otherushortColumn = column.CloneAsUInt16Column();
-            return ElementwiseEqualsImplementation(otherushortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherushortColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(SByteDataFrameColumn column)
         {
             UInt16DataFrameColumn otherushortColumn = column.CloneAsUInt16Column();
-            return ElementwiseNotEqualsImplementation(otherushortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherushortColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(SByteDataFrameColumn column)
         {
             UInt16DataFrameColumn otherushortColumn = column.CloneAsUInt16Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherushortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherushortColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(SByteDataFrameColumn column)
         {
             UInt16DataFrameColumn otherushortColumn = column.CloneAsUInt16Column();
-            return ElementwiseLessThanOrEqualImplementation(otherushortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherushortColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(SByteDataFrameColumn column)
         {
             UInt16DataFrameColumn otherushortColumn = column.CloneAsUInt16Column();
-            return ElementwiseGreaterThanImplementation(otherushortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherushortColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(SByteDataFrameColumn column)
         {
             UInt16DataFrameColumn otherushortColumn = column.CloneAsUInt16Column();
-            return ElementwiseLessThanImplementation(otherushortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherushortColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(Int16DataFrameColumn column)
         {
             UInt16DataFrameColumn otherushortColumn = column.CloneAsUInt16Column();
-            return ElementwiseEqualsImplementation(otherushortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherushortColumn);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(Int16DataFrameColumn column)
         {
             UInt16DataFrameColumn otherushortColumn = column.CloneAsUInt16Column();
-            return ElementwiseNotEqualsImplementation(otherushortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherushortColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(Int16DataFrameColumn column)
         {
             UInt16DataFrameColumn otherushortColumn = column.CloneAsUInt16Column();
-            return ElementwiseGreaterThanOrEqualImplementation(otherushortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherushortColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(Int16DataFrameColumn column)
         {
             UInt16DataFrameColumn otherushortColumn = column.CloneAsUInt16Column();
-            return ElementwiseLessThanOrEqualImplementation(otherushortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherushortColumn);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(Int16DataFrameColumn column)
         {
             UInt16DataFrameColumn otherushortColumn = column.CloneAsUInt16Column();
-            return ElementwiseGreaterThanImplementation(otherushortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherushortColumn);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(Int16DataFrameColumn column)
         {
             UInt16DataFrameColumn otherushortColumn = column.CloneAsUInt16Column();
-            return ElementwiseLessThanImplementation(otherushortColumn);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherushortColumn);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseEqualsImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseNotEqualsImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseGreaterThanImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt32DataFrameColumn column)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseLessThanImplementation(column);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseEqualsImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseNotEqualsImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanOrEqualImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanOrEqualImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt64DataFrameColumn column)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanImplementation(column);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
         public BooleanDataFrameColumn ElementwiseEquals(UInt16DataFrameColumn column)
         {
-            return ElementwiseEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(UInt16DataFrameColumn column)
         {
-            return ElementwiseNotEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(UInt16DataFrameColumn column)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(UInt16DataFrameColumn column)
         {
-            return ElementwiseLessThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(UInt16DataFrameColumn column)
         {
-            return ElementwiseGreaterThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(UInt16DataFrameColumn column)
         {
-            return ElementwiseLessThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
     }
+
     public partial class DateTimeDataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(DateTimeDataFrameColumn column)
         {
-            return ElementwiseEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DateTimeDataFrameColumn column)
         {
-            return ElementwiseNotEqualsImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DateTimeDataFrameColumn column)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DateTimeDataFrameColumn column)
         {
-            return ElementwiseLessThanOrEqualImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, column);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DateTimeDataFrameColumn column)
         {
-            return ElementwiseGreaterThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, column);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DateTimeDataFrameColumn column)
         {
-            return ElementwiseLessThanImplementation(column);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, column);
         }
     }
+
     public partial class BooleanDataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(bool value)
         {
-            return ElementwiseEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(bool value)
         {
-            return ElementwiseNotEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(bool value)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(bool value)
         {
-            return ElementwiseLessThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(bool value)
         {
-            return ElementwiseGreaterThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(bool value)
         {
-            return ElementwiseLessThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
     }
+
     public partial class ByteDataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
-            return ElementwiseEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
-            return ElementwiseNotEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
-            return ElementwiseLessThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
-            return ElementwiseGreaterThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
-            return ElementwiseLessThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseEqualsImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseNotEqualsImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseEqualsImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseNotEqualsImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseEqualsImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseNotEqualsImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseEqualsImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseNotEqualsImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseGreaterThanImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseLessThanImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseEqualsImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseNotEqualsImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             byte otherbyteValue = (byte)value;
-            return ElementwiseEqualsImplementation(otherbyteValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             byte otherbyteValue = (byte)value;
-            return ElementwiseNotEqualsImplementation(otherbyteValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             byte otherbyteValue = (byte)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherbyteValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             byte otherbyteValue = (byte)value;
-            return ElementwiseLessThanOrEqualImplementation(otherbyteValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             byte otherbyteValue = (byte)value;
-            return ElementwiseGreaterThanImplementation(otherbyteValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             byte otherbyteValue = (byte)value;
-            return ElementwiseLessThanImplementation(otherbyteValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseEqualsImplementation(value);
+            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseNotEqualsImplementation(value);
+            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseGreaterThanImplementation(value);
+            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseLessThanImplementation(value);
+            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseEqualsImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseNotEqualsImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseGreaterThanImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseLessThanImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseEqualsImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseNotEqualsImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseEqualsImplementation(value);
+            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseNotEqualsImplementation(value);
+            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseGreaterThanImplementation(value);
+            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseLessThanImplementation(value);
+            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseEqualsImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseNotEqualsImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseLessThanOrEqualImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseGreaterThanImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseLessThanImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(decimal value)
         {
-            return ElementwiseEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(decimal value)
         {
-            return ElementwiseNotEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(decimal value)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(decimal value)
         {
-            return ElementwiseLessThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(decimal value)
         {
-            return ElementwiseGreaterThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(decimal value)
         {
-            return ElementwiseLessThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseEqualsImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseNotEqualsImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseLessThanOrEqualImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseGreaterThanImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseLessThanImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseEqualsImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseNotEqualsImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseLessThanOrEqualImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseGreaterThanImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseLessThanImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseEqualsImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseNotEqualsImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseLessThanOrEqualImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseGreaterThanImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseLessThanImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseEqualsImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseNotEqualsImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseLessThanOrEqualImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseGreaterThanImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseLessThanImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseEqualsImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseNotEqualsImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseLessThanOrEqualImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseGreaterThanImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseLessThanImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseEqualsImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseNotEqualsImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseLessThanOrEqualImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseGreaterThanImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseLessThanImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseEqualsImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseNotEqualsImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseLessThanOrEqualImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseGreaterThanImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return ElementwiseLessThanImplementation(otherdecimalValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdecimalValue);
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseEqualsImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseNotEqualsImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseLessThanOrEqualImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseGreaterThanImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseLessThanImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
-            return ElementwiseEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
-            return ElementwiseNotEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
-            return ElementwiseLessThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
-            return ElementwiseGreaterThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
-            return ElementwiseLessThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseEqualsImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseNotEqualsImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseLessThanOrEqualImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseGreaterThanImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseLessThanImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseEqualsImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseNotEqualsImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseLessThanOrEqualImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseGreaterThanImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseLessThanImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseEqualsImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseNotEqualsImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseLessThanOrEqualImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseGreaterThanImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseLessThanImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseEqualsImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseNotEqualsImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseLessThanOrEqualImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseGreaterThanImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseLessThanImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseEqualsImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseNotEqualsImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseLessThanOrEqualImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseGreaterThanImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseLessThanImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseEqualsImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseNotEqualsImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseLessThanOrEqualImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseGreaterThanImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseLessThanImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseEqualsImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseNotEqualsImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseLessThanOrEqualImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseGreaterThanImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseLessThanImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseEqualsImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseNotEqualsImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseLessThanOrEqualImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseGreaterThanImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             double otherdoubleValue = (double)value;
-            return ElementwiseLessThanImplementation(otherdoubleValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdoubleValue);
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseEqualsImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseNotEqualsImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseLessThanOrEqualImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseGreaterThanImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseLessThanImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseEqualsImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseNotEqualsImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
-            return ElementwiseEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
-            return ElementwiseNotEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
-            return ElementwiseLessThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
-            return ElementwiseGreaterThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
-            return ElementwiseLessThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseEqualsImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseNotEqualsImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseLessThanOrEqualImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseGreaterThanImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseLessThanImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseEqualsImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseNotEqualsImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseLessThanOrEqualImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseGreaterThanImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseLessThanImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseEqualsImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseNotEqualsImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseLessThanOrEqualImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseGreaterThanImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseLessThanImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseEqualsImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseNotEqualsImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseLessThanOrEqualImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseGreaterThanImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseLessThanImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseEqualsImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseNotEqualsImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseLessThanOrEqualImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseGreaterThanImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseLessThanImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseEqualsImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseNotEqualsImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseLessThanOrEqualImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseGreaterThanImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseLessThanImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseEqualsImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseNotEqualsImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseLessThanOrEqualImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseGreaterThanImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             float otherfloatValue = (float)value;
-            return ElementwiseLessThanImplementation(otherfloatValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherfloatValue);
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             int otherintValue = (int)value;
-            return ElementwiseEqualsImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             int otherintValue = (int)value;
-            return ElementwiseNotEqualsImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             int otherintValue = (int)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             int otherintValue = (int)value;
-            return ElementwiseLessThanOrEqualImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             int otherintValue = (int)value;
-            return ElementwiseGreaterThanImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             int otherintValue = (int)value;
-            return ElementwiseLessThanImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseEqualsImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseNotEqualsImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseEqualsImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseNotEqualsImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseEqualsImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseNotEqualsImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
-            return ElementwiseEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
-            return ElementwiseNotEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
-            return ElementwiseLessThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
-            return ElementwiseGreaterThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
-            return ElementwiseLessThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseEqualsImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseNotEqualsImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             int otherintValue = (int)value;
-            return ElementwiseEqualsImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             int otherintValue = (int)value;
-            return ElementwiseNotEqualsImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             int otherintValue = (int)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             int otherintValue = (int)value;
-            return ElementwiseLessThanOrEqualImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             int otherintValue = (int)value;
-            return ElementwiseGreaterThanImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             int otherintValue = (int)value;
-            return ElementwiseLessThanImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             int otherintValue = (int)value;
-            return ElementwiseEqualsImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             int otherintValue = (int)value;
-            return ElementwiseNotEqualsImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             int otherintValue = (int)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             int otherintValue = (int)value;
-            return ElementwiseLessThanOrEqualImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             int otherintValue = (int)value;
-            return ElementwiseGreaterThanImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             int otherintValue = (int)value;
-            return ElementwiseLessThanImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             int otherintValue = (int)value;
-            return ElementwiseEqualsImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             int otherintValue = (int)value;
-            return ElementwiseNotEqualsImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             int otherintValue = (int)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             int otherintValue = (int)value;
-            return ElementwiseLessThanOrEqualImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             int otherintValue = (int)value;
-            return ElementwiseGreaterThanImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             int otherintValue = (int)value;
-            return ElementwiseLessThanImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseEqualsImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseNotEqualsImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             int otherintValue = (int)value;
-            return ElementwiseEqualsImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             int otherintValue = (int)value;
-            return ElementwiseNotEqualsImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             int otherintValue = (int)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             int otherintValue = (int)value;
-            return ElementwiseLessThanOrEqualImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             int otherintValue = (int)value;
-            return ElementwiseGreaterThanImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             int otherintValue = (int)value;
-            return ElementwiseLessThanImplementation(otherintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherintValue);
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseEqualsImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseNotEqualsImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseLessThanOrEqualImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseGreaterThanImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseLessThanImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseEqualsImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseNotEqualsImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseEqualsImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseNotEqualsImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseEqualsImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseNotEqualsImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseEqualsImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseNotEqualsImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseLessThanOrEqualImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseGreaterThanImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseLessThanImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
-            return ElementwiseEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
-            return ElementwiseNotEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
-            return ElementwiseLessThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
-            return ElementwiseGreaterThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
-            return ElementwiseLessThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseEqualsImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseNotEqualsImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseLessThanOrEqualImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseGreaterThanImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseLessThanImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseEqualsImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseNotEqualsImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseLessThanOrEqualImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseGreaterThanImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseLessThanImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseEqualsImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseNotEqualsImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseLessThanOrEqualImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseGreaterThanImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseLessThanImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseEqualsImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseNotEqualsImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseLessThanOrEqualImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseGreaterThanImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             long otherlongValue = (long)value;
-            return ElementwiseLessThanImplementation(otherlongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherlongValue);
         }
     }
+
     public partial class SByteDataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             sbyte othersbyteValue = (sbyte)value;
-            return ElementwiseEqualsImplementation(othersbyteValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, othersbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             sbyte othersbyteValue = (sbyte)value;
-            return ElementwiseNotEqualsImplementation(othersbyteValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, othersbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             sbyte othersbyteValue = (sbyte)value;
-            return ElementwiseGreaterThanOrEqualImplementation(othersbyteValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, othersbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             sbyte othersbyteValue = (sbyte)value;
-            return ElementwiseLessThanOrEqualImplementation(othersbyteValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, othersbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             sbyte othersbyteValue = (sbyte)value;
-            return ElementwiseGreaterThanImplementation(othersbyteValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, othersbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             sbyte othersbyteValue = (sbyte)value;
-            return ElementwiseLessThanImplementation(othersbyteValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, othersbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseEqualsImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseNotEqualsImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseEqualsImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseNotEqualsImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseEqualsImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseNotEqualsImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseEqualsImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseNotEqualsImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseGreaterThanImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseLessThanImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseEqualsImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseNotEqualsImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
-            return ElementwiseEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
-            return ElementwiseNotEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
-            return ElementwiseLessThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
-            return ElementwiseGreaterThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
-            return ElementwiseLessThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseEqualsImplementation(value);
+            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseNotEqualsImplementation(value);
+            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseGreaterThanImplementation(value);
+            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.ElementwiseLessThanImplementation(value);
+            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseEqualsImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseNotEqualsImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseGreaterThanImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseLessThanImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseEqualsImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseNotEqualsImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseEqualsImplementation(value);
+            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseNotEqualsImplementation(value);
+            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseGreaterThanImplementation(value);
+            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.ElementwiseLessThanImplementation(value);
+            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
     }
+
     public partial class Int16DataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             short othershortValue = (short)value;
-            return ElementwiseEqualsImplementation(othershortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             short othershortValue = (short)value;
-            return ElementwiseNotEqualsImplementation(othershortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             short othershortValue = (short)value;
-            return ElementwiseGreaterThanOrEqualImplementation(othershortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             short othershortValue = (short)value;
-            return ElementwiseLessThanOrEqualImplementation(othershortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             short othershortValue = (short)value;
-            return ElementwiseGreaterThanImplementation(othershortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             short othershortValue = (short)value;
-            return ElementwiseLessThanImplementation(othershortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseEqualsImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseNotEqualsImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseEqualsImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseNotEqualsImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseEqualsImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseNotEqualsImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseEqualsImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseNotEqualsImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseGreaterThanImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseLessThanImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseEqualsImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseNotEqualsImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             short othershortValue = (short)value;
-            return ElementwiseEqualsImplementation(othershortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             short othershortValue = (short)value;
-            return ElementwiseNotEqualsImplementation(othershortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             short othershortValue = (short)value;
-            return ElementwiseGreaterThanOrEqualImplementation(othershortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             short othershortValue = (short)value;
-            return ElementwiseLessThanOrEqualImplementation(othershortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             short othershortValue = (short)value;
-            return ElementwiseGreaterThanImplementation(othershortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             short othershortValue = (short)value;
-            return ElementwiseLessThanImplementation(othershortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
-            return ElementwiseEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
-            return ElementwiseNotEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
-            return ElementwiseLessThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
-            return ElementwiseGreaterThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
-            return ElementwiseLessThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseEqualsImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseNotEqualsImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseGreaterThanImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseLessThanImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseEqualsImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseNotEqualsImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             short othershortValue = (short)value;
-            return ElementwiseEqualsImplementation(othershortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             short othershortValue = (short)value;
-            return ElementwiseNotEqualsImplementation(othershortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             short othershortValue = (short)value;
-            return ElementwiseGreaterThanOrEqualImplementation(othershortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             short othershortValue = (short)value;
-            return ElementwiseLessThanOrEqualImplementation(othershortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             short othershortValue = (short)value;
-            return ElementwiseGreaterThanImplementation(othershortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             short othershortValue = (short)value;
-            return ElementwiseLessThanImplementation(othershortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, othershortValue);
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseEqualsImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseNotEqualsImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseLessThanOrEqualImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseGreaterThanImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseLessThanImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseEqualsImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseNotEqualsImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseEqualsImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseNotEqualsImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseEqualsImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseNotEqualsImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseEqualsImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseNotEqualsImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseLessThanOrEqualImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseGreaterThanImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseLessThanImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseEqualsImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseNotEqualsImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseEqualsImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseNotEqualsImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseLessThanOrEqualImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseGreaterThanImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseLessThanImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseEqualsImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseNotEqualsImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseLessThanOrEqualImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseGreaterThanImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseLessThanImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
-            return ElementwiseEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
-            return ElementwiseNotEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
-            return ElementwiseLessThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
-            return ElementwiseGreaterThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
-            return ElementwiseLessThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseEqualsImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseNotEqualsImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseEqualsImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseNotEqualsImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseLessThanOrEqualImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseGreaterThanImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             uint otheruintValue = (uint)value;
-            return ElementwiseLessThanImplementation(otheruintValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otheruintValue);
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseEqualsImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseNotEqualsImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseLessThanOrEqualImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseGreaterThanImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseLessThanImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseEqualsImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseNotEqualsImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseEqualsImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseNotEqualsImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseEqualsImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseNotEqualsImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseEqualsImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseNotEqualsImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseLessThanOrEqualImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseGreaterThanImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseLessThanImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseEqualsImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseNotEqualsImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseLessThanOrEqualImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseGreaterThanImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseLessThanImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseEqualsImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseNotEqualsImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseLessThanOrEqualImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseGreaterThanImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseLessThanImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseEqualsImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseNotEqualsImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseLessThanOrEqualImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseGreaterThanImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseLessThanImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
-            return ElementwiseEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
-            return ElementwiseNotEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
-            return ElementwiseLessThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
-            return ElementwiseGreaterThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
-            return ElementwiseLessThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseEqualsImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseNotEqualsImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseLessThanOrEqualImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseGreaterThanImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             ulong otherulongValue = (ulong)value;
-            return ElementwiseLessThanImplementation(otherulongValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherulongValue);
         }
     }
+
     public partial class UInt16DataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             ushort otherushortValue = (ushort)value;
-            return ElementwiseEqualsImplementation(otherushortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             ushort otherushortValue = (ushort)value;
-            return ElementwiseNotEqualsImplementation(otherushortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             ushort otherushortValue = (ushort)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherushortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             ushort otherushortValue = (ushort)value;
-            return ElementwiseLessThanOrEqualImplementation(otherushortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             ushort otherushortValue = (ushort)value;
-            return ElementwiseGreaterThanImplementation(otherushortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             ushort otherushortValue = (ushort)value;
-            return ElementwiseLessThanImplementation(otherushortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseEqualsImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseNotEqualsImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseGreaterThanImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.ElementwiseLessThanImplementation(value);
+            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseEqualsImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseNotEqualsImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseGreaterThanImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.ElementwiseLessThanImplementation(value);
+            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseEqualsImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseNotEqualsImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseGreaterThanImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.ElementwiseLessThanImplementation(value);
+            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseEqualsImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseNotEqualsImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseGreaterThanImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.ElementwiseLessThanImplementation(value);
+            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseEqualsImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseNotEqualsImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseGreaterThanImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.ElementwiseLessThanImplementation(value);
+            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             ushort otherushortValue = (ushort)value;
-            return ElementwiseEqualsImplementation(otherushortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             ushort otherushortValue = (ushort)value;
-            return ElementwiseNotEqualsImplementation(otherushortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             ushort otherushortValue = (ushort)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherushortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             ushort otherushortValue = (ushort)value;
-            return ElementwiseLessThanOrEqualImplementation(otherushortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             ushort otherushortValue = (ushort)value;
-            return ElementwiseGreaterThanImplementation(otherushortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             ushort otherushortValue = (ushort)value;
-            return ElementwiseLessThanImplementation(otherushortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             ushort otherushortValue = (ushort)value;
-            return ElementwiseEqualsImplementation(otherushortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             ushort otherushortValue = (ushort)value;
-            return ElementwiseNotEqualsImplementation(otherushortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             ushort otherushortValue = (ushort)value;
-            return ElementwiseGreaterThanOrEqualImplementation(otherushortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             ushort otherushortValue = (ushort)value;
-            return ElementwiseLessThanOrEqualImplementation(otherushortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             ushort otherushortValue = (ushort)value;
-            return ElementwiseGreaterThanImplementation(otherushortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             ushort otherushortValue = (ushort)value;
-            return ElementwiseLessThanImplementation(otherushortValue);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseEqualsImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseNotEqualsImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseGreaterThanImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.ElementwiseLessThanImplementation(value);
+            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseEqualsImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseNotEqualsImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanOrEqualImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanOrEqualImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseGreaterThanImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.ElementwiseLessThanImplementation(value);
+            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
-            return ElementwiseEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
-            return ElementwiseNotEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
-            return ElementwiseLessThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
-            return ElementwiseGreaterThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
-            return ElementwiseLessThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
     }
+
     public partial class DateTimeDataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(DateTime value)
         {
-            return ElementwiseEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DateTime value)
         {
-            return ElementwiseNotEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DateTime value)
         {
-            return ElementwiseGreaterThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DateTime value)
         {
-            return ElementwiseLessThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DateTime value)
         {
-            return ElementwiseGreaterThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DateTime value)
         {
-            return ElementwiseLessThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
     }
 
+
     public partial class ByteDataFrameColumn
     {
         public new Int32DataFrameColumn LeftShift(int value, bool inPlace = false)
@@ -15756,6 +15811,7 @@ public partial class ByteDataFrameColumn
             return new Int32DataFrameColumn(result.Name, result.ColumnContainer);
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         public new Int32DataFrameColumn LeftShift(int value, bool inPlace = false)
@@ -15764,6 +15820,7 @@ public partial class Int32DataFrameColumn
             return new Int32DataFrameColumn(result.Name, result.ColumnContainer);
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         public new Int64DataFrameColumn LeftShift(int value, bool inPlace = false)
@@ -15772,6 +15829,7 @@ public partial class Int64DataFrameColumn
             return new Int64DataFrameColumn(result.Name, result.ColumnContainer);
         }
     }
+
     public partial class SByteDataFrameColumn
     {
         public new Int32DataFrameColumn LeftShift(int value, bool inPlace = false)
@@ -15781,6 +15839,7 @@ public partial class SByteDataFrameColumn
             return new Int32DataFrameColumn(result.Name, result.ColumnContainer);
         }
     }
+
     public partial class Int16DataFrameColumn
     {
         public new Int32DataFrameColumn LeftShift(int value, bool inPlace = false)
@@ -15790,6 +15849,7 @@ public partial class Int16DataFrameColumn
             return new Int32DataFrameColumn(result.Name, result.ColumnContainer);
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         public new UInt32DataFrameColumn LeftShift(int value, bool inPlace = false)
@@ -15798,6 +15858,7 @@ public partial class UInt32DataFrameColumn
             return new UInt32DataFrameColumn(result.Name, result.ColumnContainer);
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         public new UInt64DataFrameColumn LeftShift(int value, bool inPlace = false)
@@ -15806,6 +15867,7 @@ public partial class UInt64DataFrameColumn
             return new UInt64DataFrameColumn(result.Name, result.ColumnContainer);
         }
     }
+
     public partial class UInt16DataFrameColumn
     {
         public new Int32DataFrameColumn LeftShift(int value, bool inPlace = false)
@@ -15815,6 +15877,7 @@ public partial class UInt16DataFrameColumn
             return new Int32DataFrameColumn(result.Name, result.ColumnContainer);
         }
     }
+
     public partial class ByteDataFrameColumn
     {
         public new Int32DataFrameColumn RightShift(int value, bool inPlace = false)
@@ -15824,6 +15887,7 @@ public partial class ByteDataFrameColumn
             return new Int32DataFrameColumn(result.Name, result.ColumnContainer);
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         public new Int32DataFrameColumn RightShift(int value, bool inPlace = false)
@@ -15832,6 +15896,7 @@ public partial class Int32DataFrameColumn
             return new Int32DataFrameColumn(result.Name, result.ColumnContainer);
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         public new Int64DataFrameColumn RightShift(int value, bool inPlace = false)
@@ -15840,6 +15905,7 @@ public partial class Int64DataFrameColumn
             return new Int64DataFrameColumn(result.Name, result.ColumnContainer);
         }
     }
+
     public partial class SByteDataFrameColumn
     {
         public new Int32DataFrameColumn RightShift(int value, bool inPlace = false)
@@ -15849,6 +15915,7 @@ public partial class SByteDataFrameColumn
             return new Int32DataFrameColumn(result.Name, result.ColumnContainer);
         }
     }
+
     public partial class Int16DataFrameColumn
     {
         public new Int32DataFrameColumn RightShift(int value, bool inPlace = false)
@@ -15858,6 +15925,7 @@ public partial class Int16DataFrameColumn
             return new Int32DataFrameColumn(result.Name, result.ColumnContainer);
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         public new UInt32DataFrameColumn RightShift(int value, bool inPlace = false)
@@ -15866,6 +15934,7 @@ public partial class UInt32DataFrameColumn
             return new UInt32DataFrameColumn(result.Name, result.ColumnContainer);
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         public new UInt64DataFrameColumn RightShift(int value, bool inPlace = false)
@@ -15874,6 +15943,7 @@ public partial class UInt64DataFrameColumn
             return new UInt64DataFrameColumn(result.Name, result.ColumnContainer);
         }
     }
+
     public partial class UInt16DataFrameColumn
     {
         public new Int32DataFrameColumn RightShift(int value, bool inPlace = false)
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationAPIs.ExplodedColumns.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationAPIs.ExplodedColumns.tt
index e0e9067917..a6efa5cb4a 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationAPIs.ExplodedColumns.tt
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationAPIs.ExplodedColumns.tt
@@ -29,7 +29,7 @@ bool supportedInPlace(string type1, string type2)
 }
 #>
 <# 
-void GenerateAllBinaryCombinationsForMethod()
+void GenerateAllBinaryCombinations()
 {
     HashSet<string> visited = new HashSet<string> { };
  foreach (TypeCombination outer in BinaryOperationCombinations.binaryOperationCombinations) 
@@ -42,6 +42,7 @@ void GenerateAllBinaryCombinationsForMethod()
     visited.Add(outerColumnType);
     string fullOuterColumnType = GetCapitalizedPrimitiveTypes(outerColumnType) + "DataFrameColumn";
 #>
+
     public partial class <#=fullOuterColumnType#>
     {
 <#
@@ -84,16 +85,16 @@ void GenerateAllBinaryCombinationsForMethod()
         if (fullReturnType == fullColumnType || fullReturnType == fullOtherColumnType)
         {
 #>
-            return <#=methodName#>Implementation(column, inPlace);
+            return HandleOperationImplementation(BinaryOperation.<#=methodName#>, column, inPlace);
 <#
         }
         else
         {
             // Cases such as byte + byte resulting in int. Needs 2 clones
 #>
-            <#=fullReturnType#> <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
-            <#=fullReturnType#> other<#=returnType#>Column = column.CloneAs<#=capitalizedReturnType#>Column();
-            return <#=returnType#>Column.<#=methodName#>Implementation(other<#=returnType#>Column, inPlace: true);
+            var <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
+            var other<#=returnType#>Column = column.CloneAs<#=capitalizedReturnType#>Column();
+            return <#=returnType#>Column.HandleOperationImplementation(BinaryOperation.<#=methodName#>, other<#=returnType#>Column, inPlace: true);
 <#
         }
     }
@@ -107,15 +108,15 @@ void GenerateAllBinaryCombinationsForMethod()
             if (otherColumnTypeLevel > columnTypeLevel)
             {
 #>
-            <#=fullReturnType#> <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
-            return <#=returnType#>Column.<#=methodName#>Implementation(column, inPlace: true);
+            var <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
+            return <#=returnType#>Column.HandleOperationImplementation(BinaryOperation.<#=methodName#>, column, inPlace: true);
 <#
             }
             else
             {
 #>
-            <#=fullReturnType#> other<#=returnType#>Column = column.CloneAs<#=capitalizedReturnType#>Column();
-            return <#=methodName#>Implementation(other<#=returnType#>Column, inPlace);
+            var other<#=returnType#>Column = column.CloneAs<#=capitalizedReturnType#>Column();
+            return HandleOperationImplementation(BinaryOperation.<#=methodName#>, other<#=returnType#>Column, inPlace);
 <#
             }
         }
@@ -123,9 +124,9 @@ void GenerateAllBinaryCombinationsForMethod()
         {
             // Cases such as byte + short resulting in int. Needs 2 clones
 #>
-            <#=fullReturnType#> <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
-            <#=fullReturnType#> other<#=returnType#>Column = column.CloneAs<#=capitalizedReturnType#>Column();
-            return <#=returnType#>Column.<#=methodName#>Implementation(other<#=returnType#>Column, inPlace: true);
+            var <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
+            var other<#=returnType#>Column = column.CloneAs<#=capitalizedReturnType#>Column();
+            return <#=returnType#>Column.HandleOperationImplementation(BinaryOperation.<#=methodName#>, other<#=returnType#>Column, inPlace: true);
 <#
         }
     }
@@ -155,6 +156,7 @@ void GenerateAllBinaryScalarCombinationsForMethod()
     visited.Add(outerColumnType);
     string fullOuterColumnType = GetCapitalizedPrimitiveTypes(outerColumnType) + "DataFrameColumn";
 #>
+
     public partial class <#=fullOuterColumnType#>
     {
 <#
@@ -197,15 +199,15 @@ void GenerateAllBinaryScalarCombinationsForMethod()
         if (fullReturnType == fullColumnType)
         {
 #>
-            return <#=methodName#>Implementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.<#=methodName#>, value, inPlace);
 <#
         }
         else
         {
             // Cases such as byte + byte resulting in int. Needs 2 clones
 #>
-            <#=fullReturnType#> <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
-            return <#=returnType#>Column.<#=methodName#>Implementation(value, inPlace: true);
+            var <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
+            return <#=returnType#>Column.HandleOperationImplementation(BinaryScalarOperation.<#=methodName#>, value, inPlace: true);
 <#
         }
     }
@@ -219,15 +221,15 @@ void GenerateAllBinaryScalarCombinationsForMethod()
             if (valueTypeLevel > columnTypeLevel)
             {
 #>
-            <#=fullReturnType#> <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
-            return <#=returnType#>Column.<#=methodName#>Implementation(value, inPlace: true);
+            var <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
+            return <#=returnType#>Column.HandleOperationImplementation(BinaryScalarOperation.<#=methodName#>, value, inPlace: true);
 <#
             }
             else
             {
 #>
-            <#=returnType#> convertedValue = (<#=returnType#>)value;
-            return <#=methodName#>Implementation(convertedValue, inPlace);
+            var convertedValue = (<#=returnType#>)value;
+            return HandleOperationImplementation(BinaryScalarOperation.<#=methodName#>, convertedValue, inPlace);
 <#
             }
         }
@@ -235,8 +237,8 @@ void GenerateAllBinaryScalarCombinationsForMethod()
         {
             // Cases such as byte + short resulting in int. Needs 2 clones
 #>
-            <#=fullReturnType#> <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
-            return <#=returnType#>Column.<#=methodName#>Implementation(value, inPlace: true);
+            var <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
+            return <#=returnType#>Column.HandleOperationImplementation(BinaryScalarOperation.<#=methodName#>, value, inPlace: true);
 <#
         }
     }
@@ -246,6 +248,7 @@ void GenerateAllBinaryScalarCombinationsForMethod()
         }
         if (method.MethodType == MethodType.BinaryScalar && method.IsNumeric)
         {
+            string operationName = method.MethodName;
             string methodName = "Reverse" + method.MethodName;
             string returnType = types.ReturnColumnType;
             string columnType = types.ThisColumnType;
@@ -279,15 +282,15 @@ void GenerateAllBinaryScalarCombinationsForMethod()
         if (fullReturnType == fullColumnType)
         {
 #>
-            return <#=methodName#>Implementation(value, inPlace);
+            return HandleReverseOperationImplementation(BinaryScalarOperation.<#=operationName#>, value, inPlace);
 <#
         }
         else
         {
             // Cases such as byte + byte resulting in int. Needs 2 clones
 #>
-            <#=fullReturnType#> <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
-            return <#=returnType#>Column.<#=methodName#>Implementation(value, inPlace: true);
+            var <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
+            return <#=returnType#>Column.HandleReverseOperationImplementation(BinaryScalarOperation.<#=operationName#>, value, inPlace: true);
 <#
         }
     }
@@ -301,15 +304,15 @@ void GenerateAllBinaryScalarCombinationsForMethod()
             if (valueTypeLevel > columnTypeLevel)
             {
 #>
-            <#=fullReturnType#> <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
-            return <#=returnType#>Column.<#=methodName#>Implementation(value, inPlace: true);
+            var <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
+            return <#=returnType#>Column.HandleReverseOperationImplementation(BinaryScalarOperation.<#=operationName#>, value, inPlace: true);
 <#
             }
             else
             {
 #>
-            <#=returnType#> convertedValue = (<#=returnType#>)value;
-            return <#=methodName#>Implementation(convertedValue, inPlace);
+            var convertedValue = (<#=returnType#>)value;
+            return HandleReverseOperationImplementation(BinaryScalarOperation.<#=operationName#>, convertedValue, inPlace);
 <#
             }
         }
@@ -317,8 +320,8 @@ void GenerateAllBinaryScalarCombinationsForMethod()
         {
             // Cases such as byte + short resulting in int. Needs 2 clones
 #>
-            <#=fullReturnType#> <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
-            return <#=returnType#>Column.<#=methodName#>Implementation(value, inPlace: true);
+            var <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
+            return <#=returnType#>Column.HandleReverseOperationImplementation(BinaryScalarOperation.<#=operationName#>, value, inPlace: true);
 <#
         }
     }
@@ -338,6 +341,7 @@ void GenerateAllBinaryScalarCombinationsForMethod()
 void GenerateAllBinaryBitwiseOperationsForMethod(string methodName)
 {
 #>
+
     public partial class BooleanDataFrameColumn
     {
         public BooleanDataFrameColumn <#=methodName#>(BooleanDataFrameColumn column, bool inPlace = false)
@@ -347,7 +351,7 @@ void GenerateAllBinaryBitwiseOperationsForMethod(string methodName)
                 throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
             }
             BooleanDataFrameColumn retColumn = inPlace ? this : CloneAsBooleanColumn();
-            retColumn.ColumnContainer.<#=methodName#>(column.ColumnContainer);
+            retColumn.ColumnContainer.HandleOperation(BinaryOperation.<#=methodName#>, column.ColumnContainer);
             return retColumn;
         }
     }
@@ -358,12 +362,13 @@ void GenerateAllBinaryBitwiseOperationsForMethod(string methodName)
 void GenerateAllBinaryScalarBitwiseOperationsForMethod(string methodName)
 {
 #>
+
     public partial class BooleanDataFrameColumn
     {
         public new BooleanDataFrameColumn <#=methodName#>(bool value, bool inPlace = false)
         {
             BooleanDataFrameColumn retColumn = inPlace ? this : CloneAsBooleanColumn();
-            retColumn.ColumnContainer.<#=methodName#>(value);
+            retColumn.ColumnContainer.HandleOperation(BinaryScalarOperation.<#=methodName#>, value);
             return retColumn;
         }
     }
@@ -371,7 +376,7 @@ void GenerateAllBinaryScalarBitwiseOperationsForMethod(string methodName)
 }
 #>
 <#
-        GenerateAllBinaryCombinationsForMethod();
+        GenerateAllBinaryCombinations();
         GenerateAllBinaryScalarCombinationsForMethod();
 foreach (MethodConfiguration method in methodConfiguration)
 {
@@ -399,6 +404,7 @@ void GenerateAllComparisonCombinationsForMethod()
     visited.Add(outerColumnType);
     string fullOuterColumnType = GetCapitalizedPrimitiveTypes(outerColumnType) + "DataFrameColumn";
 #>
+
     public partial class <#=fullOuterColumnType#>
     {
 <#
@@ -428,7 +434,7 @@ foreach (MethodConfiguration method in methodConfiguration)
     if (columnType == otherColumnType)
     {
 #>
-            return <#=methodName#>Implementation(column);
+            return HandleOperationImplementation(ComparisonOperation.<#=methodName#>, column);
 <#
     }
     else
@@ -439,14 +445,14 @@ foreach (MethodConfiguration method in methodConfiguration)
         {
 #>
             <#=fullOtherColumnType#> <#=otherColumnType#>Column = CloneAs<#=capitalizedOtherColumnType#>Column();
-            return <#=otherColumnType#>Column.<#=methodName#>Implementation(column);
+            return <#=otherColumnType#>Column.HandleOperationImplementation(ComparisonOperation.<#=methodName#>, column);
 <#
         }
         else
         {
 #>
             <#=fullColumnType#> other<#=columnType#>Column = column.CloneAs<#=capitalizedColumnType#>Column();
-            return <#=methodName#>Implementation(other<#=columnType#>Column);
+            return HandleOperationImplementation(ComparisonOperation.<#=methodName#>, other<#=columnType#>Column);
 <#
         }
 #>
@@ -479,6 +485,7 @@ void GenerateAllComparisonScalarCombinationsForMethod()
     visited.Add(outerColumnType);
     string fullOuterColumnType = GetCapitalizedPrimitiveTypes(outerColumnType) + "DataFrameColumn";
 #>
+
     public partial class <#=fullOuterColumnType#>
     {
 <#
@@ -507,7 +514,7 @@ foreach (MethodConfiguration method in methodConfiguration)
     if (columnType == otherColumnType)
     {
 #>
-            return <#=methodName#>Implementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.<#=methodName#>, value);
 <#
     }
     else
@@ -518,14 +525,14 @@ foreach (MethodConfiguration method in methodConfiguration)
         {
 #>
             <#=fullOtherColumnType#> <#=otherColumnType#>Column = CloneAs<#=capitalizedOtherColumnType#>Column();
-            return <#=otherColumnType#>Column.<#=methodName#>Implementation(value);
+            return <#=otherColumnType#>Column.HandleOperationImplementation(ComparisonScalarOperation.<#=methodName#>, value);
 <#
         }
         else
         {
 #>
             <#=columnType#> other<#=columnType#>Value = (<#=columnType#>)value;
-            return <#=methodName#>Implementation(other<#=columnType#>Value);
+            return HandleOperationImplementation(ComparisonScalarOperation.<#=methodName#>, other<#=columnType#>Value);
 <#
         }
 #>
@@ -567,6 +574,7 @@ void GenerateAllBinaryShiftCombinationsForMethod(string methodName)
         string fullColumnType = GetCapitalizedPrimitiveTypes(type.TypeName) + "DataFrameColumn";
         string capitalizedReturnType = GetCapitalizedPrimitiveTypes(returnType);
 #>
+
     public partial class <#=fullColumnType#>
     {
         public new <#=fullReturnType#> <#=methodName#>(int value, bool inPlace = false)
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs
index 6a54acb85e..a91a63f3f7 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs
@@ -11,2407 +11,383 @@
 
 namespace Microsoft.Data.Analysis
 {
+
     public partial class DecimalDataFrameColumn
     {
-        internal DecimalDataFrameColumn AddImplementation(DecimalDataFrameColumn column, bool inPlace = false)
+        //Binary Operations
+        internal DecimalDataFrameColumn HandleOperationImplementation(BinaryOperation operation, DecimalDataFrameColumn column, bool inPlace = false)
         {
             if (column.Length != Length)
             {
                 throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
             }
-            DecimalDataFrameColumn newColumn = inPlace ? this : (DecimalDataFrameColumn)Clone();
-            newColumn.ColumnContainer.Add(column.ColumnContainer);
+            var newColumn = inPlace ? this : (DecimalDataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleOperation(operation, column.ColumnContainer);
             return newColumn;
         }
-    }
-    public partial class DoubleDataFrameColumn
-    {
-        internal DoubleDataFrameColumn AddImplementation(DoubleDataFrameColumn column, bool inPlace = false)
+
+        //Binary Scalar Operations
+        internal DecimalDataFrameColumn HandleOperationImplementation(BinaryScalarOperation operation, decimal right, bool inPlace = false)
         {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            DoubleDataFrameColumn newColumn = inPlace ? this : (DoubleDataFrameColumn)Clone();
-            newColumn.ColumnContainer.Add(column.ColumnContainer);
+            var newColumn = inPlace ? this : (DecimalDataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleOperation(operation, right);
             return newColumn;
         }
-    }
-    public partial class SingleDataFrameColumn
-    {
-        internal SingleDataFrameColumn AddImplementation(SingleDataFrameColumn column, bool inPlace = false)
+
+        internal DecimalDataFrameColumn HandleReverseOperationImplementation(BinaryScalarOperation operation, decimal right, bool inPlace = false)
         {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            SingleDataFrameColumn newColumn = inPlace ? this : (SingleDataFrameColumn)Clone();
-            newColumn.ColumnContainer.Add(column.ColumnContainer);
+            var newColumn = inPlace ? this : (DecimalDataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleReverseOperation(operation, right);
             return newColumn;
         }
     }
-    public partial class Int32DataFrameColumn
+
+    public partial class DoubleDataFrameColumn
     {
-        internal Int32DataFrameColumn AddImplementation(Int32DataFrameColumn column, bool inPlace = false)
+        //Binary Operations
+        internal DoubleDataFrameColumn HandleOperationImplementation(BinaryOperation operation, DoubleDataFrameColumn column, bool inPlace = false)
         {
             if (column.Length != Length)
             {
                 throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
             }
-            Int32DataFrameColumn newColumn = inPlace ? this : (Int32DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Add(column.ColumnContainer);
+            var newColumn = inPlace ? this : (DoubleDataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleOperation(operation, column.ColumnContainer);
             return newColumn;
         }
-    }
-    public partial class Int64DataFrameColumn
-    {
-        internal Int64DataFrameColumn AddImplementation(Int64DataFrameColumn column, bool inPlace = false)
+
+        //Binary Scalar Operations
+        internal DoubleDataFrameColumn HandleOperationImplementation(BinaryScalarOperation operation, double right, bool inPlace = false)
         {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            Int64DataFrameColumn newColumn = inPlace ? this : (Int64DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Add(column.ColumnContainer);
+            var newColumn = inPlace ? this : (DoubleDataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleOperation(operation, right);
             return newColumn;
         }
-    }
-    public partial class UInt32DataFrameColumn
-    {
-        internal UInt32DataFrameColumn AddImplementation(UInt32DataFrameColumn column, bool inPlace = false)
+
+        internal DoubleDataFrameColumn HandleReverseOperationImplementation(BinaryScalarOperation operation, double right, bool inPlace = false)
         {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            UInt32DataFrameColumn newColumn = inPlace ? this : (UInt32DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Add(column.ColumnContainer);
+            var newColumn = inPlace ? this : (DoubleDataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleReverseOperation(operation, right);
             return newColumn;
         }
     }
-    public partial class UInt64DataFrameColumn
+
+    public partial class SingleDataFrameColumn
     {
-        internal UInt64DataFrameColumn AddImplementation(UInt64DataFrameColumn column, bool inPlace = false)
+        //Binary Operations
+        internal SingleDataFrameColumn HandleOperationImplementation(BinaryOperation operation, SingleDataFrameColumn column, bool inPlace = false)
         {
             if (column.Length != Length)
             {
                 throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
             }
-            UInt64DataFrameColumn newColumn = inPlace ? this : (UInt64DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Add(column.ColumnContainer);
-            return newColumn;
-        }
-    }
-
-    public partial class DecimalDataFrameColumn
-    {
-        internal DecimalDataFrameColumn AddImplementation(decimal value, bool inPlace = false)
-        {
-            DecimalDataFrameColumn newColumn = inPlace ? this : CloneAsDecimalColumn();
-            newColumn.ColumnContainer.Add(value);
+            var newColumn = inPlace ? this : (SingleDataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleOperation(operation, column.ColumnContainer);
             return newColumn;
         }
-    }
 
-    public partial class DoubleDataFrameColumn
-    {
-        internal DoubleDataFrameColumn AddImplementation(double value, bool inPlace = false)
+        //Binary Scalar Operations
+        internal SingleDataFrameColumn HandleOperationImplementation(BinaryScalarOperation operation, float right, bool inPlace = false)
         {
-            DoubleDataFrameColumn newColumn = inPlace ? this : CloneAsDoubleColumn();
-            newColumn.ColumnContainer.Add(value);
+            var newColumn = inPlace ? this : (SingleDataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleOperation(operation, right);
             return newColumn;
         }
-    }
 
-    public partial class SingleDataFrameColumn
-    {
-        internal SingleDataFrameColumn AddImplementation(float value, bool inPlace = false)
+        internal SingleDataFrameColumn HandleReverseOperationImplementation(BinaryScalarOperation operation, float right, bool inPlace = false)
         {
-            SingleDataFrameColumn newColumn = inPlace ? this : CloneAsSingleColumn();
-            newColumn.ColumnContainer.Add(value);
+            var newColumn = inPlace ? this : (SingleDataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleReverseOperation(operation, right);
             return newColumn;
         }
     }
 
     public partial class Int32DataFrameColumn
     {
-        internal Int32DataFrameColumn AddImplementation(int value, bool inPlace = false)
-        {
-            Int32DataFrameColumn newColumn = inPlace ? this : CloneAsInt32Column();
-            newColumn.ColumnContainer.Add(value);
-            return newColumn;
-        }
-    }
-
-    public partial class Int64DataFrameColumn
-    {
-        internal Int64DataFrameColumn AddImplementation(long value, bool inPlace = false)
+        //Binary Operations
+        internal Int32DataFrameColumn HandleOperationImplementation(BinaryOperation operation, Int32DataFrameColumn column, bool inPlace = false)
         {
-            Int64DataFrameColumn newColumn = inPlace ? this : CloneAsInt64Column();
-            newColumn.ColumnContainer.Add(value);
+            if (column.Length != Length)
+            {
+                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
+            }
+            var newColumn = inPlace ? this : (Int32DataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleOperation(operation, column.ColumnContainer);
             return newColumn;
         }
-    }
 
-    public partial class UInt32DataFrameColumn
-    {
-        internal UInt32DataFrameColumn AddImplementation(uint value, bool inPlace = false)
+        //Binary Scalar Operations
+        internal Int32DataFrameColumn HandleOperationImplementation(BinaryScalarOperation operation, int right, bool inPlace = false)
         {
-            UInt32DataFrameColumn newColumn = inPlace ? this : CloneAsUInt32Column();
-            newColumn.ColumnContainer.Add(value);
+            var newColumn = inPlace ? this : (Int32DataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleOperation(operation, right);
             return newColumn;
         }
-    }
 
-    public partial class UInt64DataFrameColumn
-    {
-        internal UInt64DataFrameColumn AddImplementation(ulong value, bool inPlace = false)
+        internal Int32DataFrameColumn HandleReverseOperationImplementation(BinaryScalarOperation operation, int right, bool inPlace = false)
         {
-            UInt64DataFrameColumn newColumn = inPlace ? this : CloneAsUInt64Column();
-            newColumn.ColumnContainer.Add(value);
+            var newColumn = inPlace ? this : (Int32DataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleReverseOperation(operation, right);
             return newColumn;
         }
     }
 
-    public partial class DecimalDataFrameColumn
+    public partial class Int64DataFrameColumn
     {
-        internal DecimalDataFrameColumn ReverseAddImplementation(decimal value, bool inPlace = false)
+        //Binary Operations
+        internal Int64DataFrameColumn HandleOperationImplementation(BinaryOperation operation, Int64DataFrameColumn column, bool inPlace = false)
         {
-            DecimalDataFrameColumn newColumn = inPlace ? this : CloneAsDecimalColumn();
-            newColumn.ColumnContainer.ReverseAdd(value);
+            if (column.Length != Length)
+            {
+                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
+            }
+            var newColumn = inPlace ? this : (Int64DataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleOperation(operation, column.ColumnContainer);
             return newColumn;
         }
-    }
 
-    public partial class DoubleDataFrameColumn
-    {
-        internal DoubleDataFrameColumn ReverseAddImplementation(double value, bool inPlace = false)
+        //Binary Scalar Operations
+        internal Int64DataFrameColumn HandleOperationImplementation(BinaryScalarOperation operation, long right, bool inPlace = false)
         {
-            DoubleDataFrameColumn newColumn = inPlace ? this : CloneAsDoubleColumn();
-            newColumn.ColumnContainer.ReverseAdd(value);
+            var newColumn = inPlace ? this : (Int64DataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleOperation(operation, right);
             return newColumn;
         }
-    }
 
-    public partial class SingleDataFrameColumn
-    {
-        internal SingleDataFrameColumn ReverseAddImplementation(float value, bool inPlace = false)
+        internal Int64DataFrameColumn HandleReverseOperationImplementation(BinaryScalarOperation operation, long right, bool inPlace = false)
         {
-            SingleDataFrameColumn newColumn = inPlace ? this : CloneAsSingleColumn();
-            newColumn.ColumnContainer.ReverseAdd(value);
+            var newColumn = inPlace ? this : (Int64DataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleReverseOperation(operation, right);
             return newColumn;
         }
     }
 
-    public partial class Int32DataFrameColumn
+    public partial class UInt32DataFrameColumn
     {
-        internal Int32DataFrameColumn ReverseAddImplementation(int value, bool inPlace = false)
+        //Binary Operations
+        internal UInt32DataFrameColumn HandleOperationImplementation(BinaryOperation operation, UInt32DataFrameColumn column, bool inPlace = false)
         {
-            Int32DataFrameColumn newColumn = inPlace ? this : CloneAsInt32Column();
-            newColumn.ColumnContainer.ReverseAdd(value);
+            if (column.Length != Length)
+            {
+                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
+            }
+            var newColumn = inPlace ? this : (UInt32DataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleOperation(operation, column.ColumnContainer);
             return newColumn;
         }
-    }
 
-    public partial class Int64DataFrameColumn
-    {
-        internal Int64DataFrameColumn ReverseAddImplementation(long value, bool inPlace = false)
+        //Binary Scalar Operations
+        internal UInt32DataFrameColumn HandleOperationImplementation(BinaryScalarOperation operation, uint right, bool inPlace = false)
         {
-            Int64DataFrameColumn newColumn = inPlace ? this : CloneAsInt64Column();
-            newColumn.ColumnContainer.ReverseAdd(value);
+            var newColumn = inPlace ? this : (UInt32DataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleOperation(operation, right);
             return newColumn;
         }
-    }
 
-    public partial class UInt32DataFrameColumn
-    {
-        internal UInt32DataFrameColumn ReverseAddImplementation(uint value, bool inPlace = false)
+        internal UInt32DataFrameColumn HandleReverseOperationImplementation(BinaryScalarOperation operation, uint right, bool inPlace = false)
         {
-            UInt32DataFrameColumn newColumn = inPlace ? this : CloneAsUInt32Column();
-            newColumn.ColumnContainer.ReverseAdd(value);
+            var newColumn = inPlace ? this : (UInt32DataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleReverseOperation(operation, right);
             return newColumn;
         }
     }
 
     public partial class UInt64DataFrameColumn
     {
-        internal UInt64DataFrameColumn ReverseAddImplementation(ulong value, bool inPlace = false)
-        {
-            UInt64DataFrameColumn newColumn = inPlace ? this : CloneAsUInt64Column();
-            newColumn.ColumnContainer.ReverseAdd(value);
-            return newColumn;
-        }
-    }
-    public partial class DecimalDataFrameColumn
-    {
-        internal DecimalDataFrameColumn SubtractImplementation(DecimalDataFrameColumn column, bool inPlace = false)
+        //Binary Operations
+        internal UInt64DataFrameColumn HandleOperationImplementation(BinaryOperation operation, UInt64DataFrameColumn column, bool inPlace = false)
         {
             if (column.Length != Length)
             {
                 throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
             }
-            DecimalDataFrameColumn newColumn = inPlace ? this : (DecimalDataFrameColumn)Clone();
-            newColumn.ColumnContainer.Subtract(column.ColumnContainer);
+            var newColumn = inPlace ? this : (UInt64DataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleOperation(operation, column.ColumnContainer);
             return newColumn;
         }
-    }
-    public partial class DoubleDataFrameColumn
-    {
-        internal DoubleDataFrameColumn SubtractImplementation(DoubleDataFrameColumn column, bool inPlace = false)
+
+        //Binary Scalar Operations
+        internal UInt64DataFrameColumn HandleOperationImplementation(BinaryScalarOperation operation, ulong right, bool inPlace = false)
         {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            DoubleDataFrameColumn newColumn = inPlace ? this : (DoubleDataFrameColumn)Clone();
-            newColumn.ColumnContainer.Subtract(column.ColumnContainer);
+            var newColumn = inPlace ? this : (UInt64DataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleOperation(operation, right);
             return newColumn;
         }
-    }
-    public partial class SingleDataFrameColumn
-    {
-        internal SingleDataFrameColumn SubtractImplementation(SingleDataFrameColumn column, bool inPlace = false)
+
+        internal UInt64DataFrameColumn HandleReverseOperationImplementation(BinaryScalarOperation operation, ulong right, bool inPlace = false)
         {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            SingleDataFrameColumn newColumn = inPlace ? this : (SingleDataFrameColumn)Clone();
-            newColumn.ColumnContainer.Subtract(column.ColumnContainer);
+            var newColumn = inPlace ? this : (UInt64DataFrameColumn)Clone();
+            newColumn.ColumnContainer.HandleReverseOperation(operation, right);
             return newColumn;
         }
     }
-    public partial class Int32DataFrameColumn
+
+    public partial class BooleanDataFrameColumn
     {
-        internal Int32DataFrameColumn SubtractImplementation(Int32DataFrameColumn column, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, BooleanDataFrameColumn column)
         {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            Int32DataFrameColumn newColumn = inPlace ? this : (Int32DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Subtract(column.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
-    }
-    public partial class Int64DataFrameColumn
-    {
-        internal Int64DataFrameColumn SubtractImplementation(Int64DataFrameColumn column, bool inPlace = false)
+
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, bool value)
         {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            Int64DataFrameColumn newColumn = inPlace ? this : (Int64DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Subtract(column.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
     }
-    public partial class UInt32DataFrameColumn
+
+    public partial class ByteDataFrameColumn
     {
-        internal UInt32DataFrameColumn SubtractImplementation(UInt32DataFrameColumn column, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, ByteDataFrameColumn column)
         {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            UInt32DataFrameColumn newColumn = inPlace ? this : (UInt32DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Subtract(column.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
-    }
-    public partial class UInt64DataFrameColumn
-    {
-        internal UInt64DataFrameColumn SubtractImplementation(UInt64DataFrameColumn column, bool inPlace = false)
+
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, byte value)
         {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            UInt64DataFrameColumn newColumn = inPlace ? this : (UInt64DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Subtract(column.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
     }
 
     public partial class DecimalDataFrameColumn
     {
-        internal DecimalDataFrameColumn SubtractImplementation(decimal value, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, DecimalDataFrameColumn column)
         {
-            DecimalDataFrameColumn newColumn = inPlace ? this : CloneAsDecimalColumn();
-            newColumn.ColumnContainer.Subtract(value);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
-    }
 
-    public partial class DoubleDataFrameColumn
-    {
-        internal DoubleDataFrameColumn SubtractImplementation(double value, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, decimal value)
         {
-            DoubleDataFrameColumn newColumn = inPlace ? this : CloneAsDoubleColumn();
-            newColumn.ColumnContainer.Subtract(value);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
     }
 
-    public partial class SingleDataFrameColumn
+    public partial class DoubleDataFrameColumn
     {
-        internal SingleDataFrameColumn SubtractImplementation(float value, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, DoubleDataFrameColumn column)
         {
-            SingleDataFrameColumn newColumn = inPlace ? this : CloneAsSingleColumn();
-            newColumn.ColumnContainer.Subtract(value);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
-    }
 
-    public partial class Int32DataFrameColumn
-    {
-        internal Int32DataFrameColumn SubtractImplementation(int value, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, double value)
         {
-            Int32DataFrameColumn newColumn = inPlace ? this : CloneAsInt32Column();
-            newColumn.ColumnContainer.Subtract(value);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
     }
 
-    public partial class Int64DataFrameColumn
+    public partial class SingleDataFrameColumn
     {
-        internal Int64DataFrameColumn SubtractImplementation(long value, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, SingleDataFrameColumn column)
         {
-            Int64DataFrameColumn newColumn = inPlace ? this : CloneAsInt64Column();
-            newColumn.ColumnContainer.Subtract(value);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
-    }
 
-    public partial class UInt32DataFrameColumn
-    {
-        internal UInt32DataFrameColumn SubtractImplementation(uint value, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, float value)
         {
-            UInt32DataFrameColumn newColumn = inPlace ? this : CloneAsUInt32Column();
-            newColumn.ColumnContainer.Subtract(value);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
     }
 
-    public partial class UInt64DataFrameColumn
+    public partial class Int32DataFrameColumn
     {
-        internal UInt64DataFrameColumn SubtractImplementation(ulong value, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, Int32DataFrameColumn column)
         {
-            UInt64DataFrameColumn newColumn = inPlace ? this : CloneAsUInt64Column();
-            newColumn.ColumnContainer.Subtract(value);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
-    }
 
-    public partial class DecimalDataFrameColumn
-    {
-        internal DecimalDataFrameColumn ReverseSubtractImplementation(decimal value, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, int value)
         {
-            DecimalDataFrameColumn newColumn = inPlace ? this : CloneAsDecimalColumn();
-            newColumn.ColumnContainer.ReverseSubtract(value);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
     }
 
-    public partial class DoubleDataFrameColumn
+    public partial class Int64DataFrameColumn
     {
-        internal DoubleDataFrameColumn ReverseSubtractImplementation(double value, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, Int64DataFrameColumn column)
         {
-            DoubleDataFrameColumn newColumn = inPlace ? this : CloneAsDoubleColumn();
-            newColumn.ColumnContainer.ReverseSubtract(value);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
-    }
 
-    public partial class SingleDataFrameColumn
-    {
-        internal SingleDataFrameColumn ReverseSubtractImplementation(float value, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, long value)
         {
-            SingleDataFrameColumn newColumn = inPlace ? this : CloneAsSingleColumn();
-            newColumn.ColumnContainer.ReverseSubtract(value);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
     }
 
-    public partial class Int32DataFrameColumn
+    public partial class SByteDataFrameColumn
     {
-        internal Int32DataFrameColumn ReverseSubtractImplementation(int value, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, SByteDataFrameColumn column)
         {
-            Int32DataFrameColumn newColumn = inPlace ? this : CloneAsInt32Column();
-            newColumn.ColumnContainer.ReverseSubtract(value);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
-    }
 
-    public partial class Int64DataFrameColumn
-    {
-        internal Int64DataFrameColumn ReverseSubtractImplementation(long value, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, sbyte value)
         {
-            Int64DataFrameColumn newColumn = inPlace ? this : CloneAsInt64Column();
-            newColumn.ColumnContainer.ReverseSubtract(value);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
     }
 
-    public partial class UInt32DataFrameColumn
+    public partial class Int16DataFrameColumn
     {
-        internal UInt32DataFrameColumn ReverseSubtractImplementation(uint value, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, Int16DataFrameColumn column)
         {
-            UInt32DataFrameColumn newColumn = inPlace ? this : CloneAsUInt32Column();
-            newColumn.ColumnContainer.ReverseSubtract(value);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
-    }
 
-    public partial class UInt64DataFrameColumn
-    {
-        internal UInt64DataFrameColumn ReverseSubtractImplementation(ulong value, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, short value)
         {
-            UInt64DataFrameColumn newColumn = inPlace ? this : CloneAsUInt64Column();
-            newColumn.ColumnContainer.ReverseSubtract(value);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
     }
-    public partial class DecimalDataFrameColumn
+
+    public partial class UInt32DataFrameColumn
     {
-        internal DecimalDataFrameColumn MultiplyImplementation(DecimalDataFrameColumn column, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, UInt32DataFrameColumn column)
         {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            DecimalDataFrameColumn newColumn = inPlace ? this : (DecimalDataFrameColumn)Clone();
-            newColumn.ColumnContainer.Multiply(column.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
-    }
-    public partial class DoubleDataFrameColumn
-    {
-        internal DoubleDataFrameColumn MultiplyImplementation(DoubleDataFrameColumn column, bool inPlace = false)
+
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, uint value)
         {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            DoubleDataFrameColumn newColumn = inPlace ? this : (DoubleDataFrameColumn)Clone();
-            newColumn.ColumnContainer.Multiply(column.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
     }
-    public partial class SingleDataFrameColumn
+
+    public partial class UInt64DataFrameColumn
     {
-        internal SingleDataFrameColumn MultiplyImplementation(SingleDataFrameColumn column, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, UInt64DataFrameColumn column)
         {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            SingleDataFrameColumn newColumn = inPlace ? this : (SingleDataFrameColumn)Clone();
-            newColumn.ColumnContainer.Multiply(column.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
-    }
-    public partial class Int32DataFrameColumn
-    {
-        internal Int32DataFrameColumn MultiplyImplementation(Int32DataFrameColumn column, bool inPlace = false)
+
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, ulong value)
         {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            Int32DataFrameColumn newColumn = inPlace ? this : (Int32DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Multiply(column.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
     }
-    public partial class Int64DataFrameColumn
+
+    public partial class UInt16DataFrameColumn
     {
-        internal Int64DataFrameColumn MultiplyImplementation(Int64DataFrameColumn column, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, UInt16DataFrameColumn column)
         {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            Int64DataFrameColumn newColumn = inPlace ? this : (Int64DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Multiply(column.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
-    }
-    public partial class UInt32DataFrameColumn
-    {
-        internal UInt32DataFrameColumn MultiplyImplementation(UInt32DataFrameColumn column, bool inPlace = false)
+
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, ushort value)
         {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            UInt32DataFrameColumn newColumn = inPlace ? this : (UInt32DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Multiply(column.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
     }
-    public partial class UInt64DataFrameColumn
+
+    public partial class DateTimeDataFrameColumn
     {
-        internal UInt64DataFrameColumn MultiplyImplementation(UInt64DataFrameColumn column, bool inPlace = false)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, DateTimeDataFrameColumn column)
         {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            UInt64DataFrameColumn newColumn = inPlace ? this : (UInt64DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Multiply(column.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
-    }
 
-    public partial class DecimalDataFrameColumn
-    {
-        internal DecimalDataFrameColumn MultiplyImplementation(decimal value, bool inPlace = false)
-        {
-            DecimalDataFrameColumn newColumn = inPlace ? this : CloneAsDecimalColumn();
-            newColumn.ColumnContainer.Multiply(value);
-            return newColumn;
-        }
-    }
-
-    public partial class DoubleDataFrameColumn
-    {
-        internal DoubleDataFrameColumn MultiplyImplementation(double value, bool inPlace = false)
-        {
-            DoubleDataFrameColumn newColumn = inPlace ? this : CloneAsDoubleColumn();
-            newColumn.ColumnContainer.Multiply(value);
-            return newColumn;
-        }
-    }
-
-    public partial class SingleDataFrameColumn
-    {
-        internal SingleDataFrameColumn MultiplyImplementation(float value, bool inPlace = false)
-        {
-            SingleDataFrameColumn newColumn = inPlace ? this : CloneAsSingleColumn();
-            newColumn.ColumnContainer.Multiply(value);
-            return newColumn;
-        }
-    }
-
-    public partial class Int32DataFrameColumn
-    {
-        internal Int32DataFrameColumn MultiplyImplementation(int value, bool inPlace = false)
-        {
-            Int32DataFrameColumn newColumn = inPlace ? this : CloneAsInt32Column();
-            newColumn.ColumnContainer.Multiply(value);
-            return newColumn;
-        }
-    }
-
-    public partial class Int64DataFrameColumn
-    {
-        internal Int64DataFrameColumn MultiplyImplementation(long value, bool inPlace = false)
-        {
-            Int64DataFrameColumn newColumn = inPlace ? this : CloneAsInt64Column();
-            newColumn.ColumnContainer.Multiply(value);
-            return newColumn;
-        }
-    }
-
-    public partial class UInt32DataFrameColumn
-    {
-        internal UInt32DataFrameColumn MultiplyImplementation(uint value, bool inPlace = false)
-        {
-            UInt32DataFrameColumn newColumn = inPlace ? this : CloneAsUInt32Column();
-            newColumn.ColumnContainer.Multiply(value);
-            return newColumn;
-        }
-    }
-
-    public partial class UInt64DataFrameColumn
-    {
-        internal UInt64DataFrameColumn MultiplyImplementation(ulong value, bool inPlace = false)
-        {
-            UInt64DataFrameColumn newColumn = inPlace ? this : CloneAsUInt64Column();
-            newColumn.ColumnContainer.Multiply(value);
-            return newColumn;
-        }
-    }
-
-    public partial class DecimalDataFrameColumn
-    {
-        internal DecimalDataFrameColumn ReverseMultiplyImplementation(decimal value, bool inPlace = false)
-        {
-            DecimalDataFrameColumn newColumn = inPlace ? this : CloneAsDecimalColumn();
-            newColumn.ColumnContainer.ReverseMultiply(value);
-            return newColumn;
-        }
-    }
-
-    public partial class DoubleDataFrameColumn
-    {
-        internal DoubleDataFrameColumn ReverseMultiplyImplementation(double value, bool inPlace = false)
-        {
-            DoubleDataFrameColumn newColumn = inPlace ? this : CloneAsDoubleColumn();
-            newColumn.ColumnContainer.ReverseMultiply(value);
-            return newColumn;
-        }
-    }
-
-    public partial class SingleDataFrameColumn
-    {
-        internal SingleDataFrameColumn ReverseMultiplyImplementation(float value, bool inPlace = false)
-        {
-            SingleDataFrameColumn newColumn = inPlace ? this : CloneAsSingleColumn();
-            newColumn.ColumnContainer.ReverseMultiply(value);
-            return newColumn;
-        }
-    }
-
-    public partial class Int32DataFrameColumn
-    {
-        internal Int32DataFrameColumn ReverseMultiplyImplementation(int value, bool inPlace = false)
-        {
-            Int32DataFrameColumn newColumn = inPlace ? this : CloneAsInt32Column();
-            newColumn.ColumnContainer.ReverseMultiply(value);
-            return newColumn;
-        }
-    }
-
-    public partial class Int64DataFrameColumn
-    {
-        internal Int64DataFrameColumn ReverseMultiplyImplementation(long value, bool inPlace = false)
-        {
-            Int64DataFrameColumn newColumn = inPlace ? this : CloneAsInt64Column();
-            newColumn.ColumnContainer.ReverseMultiply(value);
-            return newColumn;
-        }
-    }
-
-    public partial class UInt32DataFrameColumn
-    {
-        internal UInt32DataFrameColumn ReverseMultiplyImplementation(uint value, bool inPlace = false)
-        {
-            UInt32DataFrameColumn newColumn = inPlace ? this : CloneAsUInt32Column();
-            newColumn.ColumnContainer.ReverseMultiply(value);
-            return newColumn;
-        }
-    }
-
-    public partial class UInt64DataFrameColumn
-    {
-        internal UInt64DataFrameColumn ReverseMultiplyImplementation(ulong value, bool inPlace = false)
-        {
-            UInt64DataFrameColumn newColumn = inPlace ? this : CloneAsUInt64Column();
-            newColumn.ColumnContainer.ReverseMultiply(value);
-            return newColumn;
-        }
-    }
-    public partial class DecimalDataFrameColumn
-    {
-        internal DecimalDataFrameColumn DivideImplementation(DecimalDataFrameColumn column, bool inPlace = false)
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            DecimalDataFrameColumn newColumn = inPlace ? this : (DecimalDataFrameColumn)Clone();
-            newColumn.ColumnContainer.Divide(column.ColumnContainer);
-            return newColumn;
-        }
-    }
-    public partial class DoubleDataFrameColumn
-    {
-        internal DoubleDataFrameColumn DivideImplementation(DoubleDataFrameColumn column, bool inPlace = false)
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            DoubleDataFrameColumn newColumn = inPlace ? this : (DoubleDataFrameColumn)Clone();
-            newColumn.ColumnContainer.Divide(column.ColumnContainer);
-            return newColumn;
-        }
-    }
-    public partial class SingleDataFrameColumn
-    {
-        internal SingleDataFrameColumn DivideImplementation(SingleDataFrameColumn column, bool inPlace = false)
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            SingleDataFrameColumn newColumn = inPlace ? this : (SingleDataFrameColumn)Clone();
-            newColumn.ColumnContainer.Divide(column.ColumnContainer);
-            return newColumn;
-        }
-    }
-    public partial class Int32DataFrameColumn
-    {
-        internal Int32DataFrameColumn DivideImplementation(Int32DataFrameColumn column, bool inPlace = false)
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            Int32DataFrameColumn newColumn = inPlace ? this : (Int32DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Divide(column.ColumnContainer);
-            return newColumn;
-        }
-    }
-    public partial class Int64DataFrameColumn
-    {
-        internal Int64DataFrameColumn DivideImplementation(Int64DataFrameColumn column, bool inPlace = false)
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            Int64DataFrameColumn newColumn = inPlace ? this : (Int64DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Divide(column.ColumnContainer);
-            return newColumn;
-        }
-    }
-    public partial class UInt32DataFrameColumn
-    {
-        internal UInt32DataFrameColumn DivideImplementation(UInt32DataFrameColumn column, bool inPlace = false)
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            UInt32DataFrameColumn newColumn = inPlace ? this : (UInt32DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Divide(column.ColumnContainer);
-            return newColumn;
-        }
-    }
-    public partial class UInt64DataFrameColumn
-    {
-        internal UInt64DataFrameColumn DivideImplementation(UInt64DataFrameColumn column, bool inPlace = false)
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            UInt64DataFrameColumn newColumn = inPlace ? this : (UInt64DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Divide(column.ColumnContainer);
-            return newColumn;
-        }
-    }
-
-    public partial class DecimalDataFrameColumn
-    {
-        internal DecimalDataFrameColumn DivideImplementation(decimal value, bool inPlace = false)
-        {
-            DecimalDataFrameColumn newColumn = inPlace ? this : CloneAsDecimalColumn();
-            newColumn.ColumnContainer.Divide(value);
-            return newColumn;
-        }
-    }
-
-    public partial class DoubleDataFrameColumn
-    {
-        internal DoubleDataFrameColumn DivideImplementation(double value, bool inPlace = false)
-        {
-            DoubleDataFrameColumn newColumn = inPlace ? this : CloneAsDoubleColumn();
-            newColumn.ColumnContainer.Divide(value);
-            return newColumn;
-        }
-    }
-
-    public partial class SingleDataFrameColumn
-    {
-        internal SingleDataFrameColumn DivideImplementation(float value, bool inPlace = false)
-        {
-            SingleDataFrameColumn newColumn = inPlace ? this : CloneAsSingleColumn();
-            newColumn.ColumnContainer.Divide(value);
-            return newColumn;
-        }
-    }
-
-    public partial class Int32DataFrameColumn
-    {
-        internal Int32DataFrameColumn DivideImplementation(int value, bool inPlace = false)
-        {
-            Int32DataFrameColumn newColumn = inPlace ? this : CloneAsInt32Column();
-            newColumn.ColumnContainer.Divide(value);
-            return newColumn;
-        }
-    }
-
-    public partial class Int64DataFrameColumn
-    {
-        internal Int64DataFrameColumn DivideImplementation(long value, bool inPlace = false)
-        {
-            Int64DataFrameColumn newColumn = inPlace ? this : CloneAsInt64Column();
-            newColumn.ColumnContainer.Divide(value);
-            return newColumn;
-        }
-    }
-
-    public partial class UInt32DataFrameColumn
-    {
-        internal UInt32DataFrameColumn DivideImplementation(uint value, bool inPlace = false)
-        {
-            UInt32DataFrameColumn newColumn = inPlace ? this : CloneAsUInt32Column();
-            newColumn.ColumnContainer.Divide(value);
-            return newColumn;
-        }
-    }
-
-    public partial class UInt64DataFrameColumn
-    {
-        internal UInt64DataFrameColumn DivideImplementation(ulong value, bool inPlace = false)
-        {
-            UInt64DataFrameColumn newColumn = inPlace ? this : CloneAsUInt64Column();
-            newColumn.ColumnContainer.Divide(value);
-            return newColumn;
-        }
-    }
-
-    public partial class DecimalDataFrameColumn
-    {
-        internal DecimalDataFrameColumn ReverseDivideImplementation(decimal value, bool inPlace = false)
-        {
-            DecimalDataFrameColumn newColumn = inPlace ? this : CloneAsDecimalColumn();
-            newColumn.ColumnContainer.ReverseDivide(value);
-            return newColumn;
-        }
-    }
-
-    public partial class DoubleDataFrameColumn
-    {
-        internal DoubleDataFrameColumn ReverseDivideImplementation(double value, bool inPlace = false)
-        {
-            DoubleDataFrameColumn newColumn = inPlace ? this : CloneAsDoubleColumn();
-            newColumn.ColumnContainer.ReverseDivide(value);
-            return newColumn;
-        }
-    }
-
-    public partial class SingleDataFrameColumn
-    {
-        internal SingleDataFrameColumn ReverseDivideImplementation(float value, bool inPlace = false)
-        {
-            SingleDataFrameColumn newColumn = inPlace ? this : CloneAsSingleColumn();
-            newColumn.ColumnContainer.ReverseDivide(value);
-            return newColumn;
-        }
-    }
-
-    public partial class Int32DataFrameColumn
-    {
-        internal Int32DataFrameColumn ReverseDivideImplementation(int value, bool inPlace = false)
-        {
-            Int32DataFrameColumn newColumn = inPlace ? this : CloneAsInt32Column();
-            newColumn.ColumnContainer.ReverseDivide(value);
-            return newColumn;
-        }
-    }
-
-    public partial class Int64DataFrameColumn
-    {
-        internal Int64DataFrameColumn ReverseDivideImplementation(long value, bool inPlace = false)
-        {
-            Int64DataFrameColumn newColumn = inPlace ? this : CloneAsInt64Column();
-            newColumn.ColumnContainer.ReverseDivide(value);
-            return newColumn;
-        }
-    }
-
-    public partial class UInt32DataFrameColumn
-    {
-        internal UInt32DataFrameColumn ReverseDivideImplementation(uint value, bool inPlace = false)
-        {
-            UInt32DataFrameColumn newColumn = inPlace ? this : CloneAsUInt32Column();
-            newColumn.ColumnContainer.ReverseDivide(value);
-            return newColumn;
-        }
-    }
-
-    public partial class UInt64DataFrameColumn
-    {
-        internal UInt64DataFrameColumn ReverseDivideImplementation(ulong value, bool inPlace = false)
-        {
-            UInt64DataFrameColumn newColumn = inPlace ? this : CloneAsUInt64Column();
-            newColumn.ColumnContainer.ReverseDivide(value);
-            return newColumn;
-        }
-    }
-    public partial class DecimalDataFrameColumn
-    {
-        internal DecimalDataFrameColumn ModuloImplementation(DecimalDataFrameColumn column, bool inPlace = false)
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            DecimalDataFrameColumn newColumn = inPlace ? this : (DecimalDataFrameColumn)Clone();
-            newColumn.ColumnContainer.Modulo(column.ColumnContainer);
-            return newColumn;
-        }
-    }
-    public partial class DoubleDataFrameColumn
-    {
-        internal DoubleDataFrameColumn ModuloImplementation(DoubleDataFrameColumn column, bool inPlace = false)
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            DoubleDataFrameColumn newColumn = inPlace ? this : (DoubleDataFrameColumn)Clone();
-            newColumn.ColumnContainer.Modulo(column.ColumnContainer);
-            return newColumn;
-        }
-    }
-    public partial class SingleDataFrameColumn
-    {
-        internal SingleDataFrameColumn ModuloImplementation(SingleDataFrameColumn column, bool inPlace = false)
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            SingleDataFrameColumn newColumn = inPlace ? this : (SingleDataFrameColumn)Clone();
-            newColumn.ColumnContainer.Modulo(column.ColumnContainer);
-            return newColumn;
-        }
-    }
-    public partial class Int32DataFrameColumn
-    {
-        internal Int32DataFrameColumn ModuloImplementation(Int32DataFrameColumn column, bool inPlace = false)
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            Int32DataFrameColumn newColumn = inPlace ? this : (Int32DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Modulo(column.ColumnContainer);
-            return newColumn;
-        }
-    }
-    public partial class Int64DataFrameColumn
-    {
-        internal Int64DataFrameColumn ModuloImplementation(Int64DataFrameColumn column, bool inPlace = false)
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            Int64DataFrameColumn newColumn = inPlace ? this : (Int64DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Modulo(column.ColumnContainer);
-            return newColumn;
-        }
-    }
-    public partial class UInt32DataFrameColumn
-    {
-        internal UInt32DataFrameColumn ModuloImplementation(UInt32DataFrameColumn column, bool inPlace = false)
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            UInt32DataFrameColumn newColumn = inPlace ? this : (UInt32DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Modulo(column.ColumnContainer);
-            return newColumn;
-        }
-    }
-    public partial class UInt64DataFrameColumn
-    {
-        internal UInt64DataFrameColumn ModuloImplementation(UInt64DataFrameColumn column, bool inPlace = false)
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            UInt64DataFrameColumn newColumn = inPlace ? this : (UInt64DataFrameColumn)Clone();
-            newColumn.ColumnContainer.Modulo(column.ColumnContainer);
-            return newColumn;
-        }
-    }
-
-    public partial class DecimalDataFrameColumn
-    {
-        internal DecimalDataFrameColumn ModuloImplementation(decimal value, bool inPlace = false)
-        {
-            DecimalDataFrameColumn newColumn = inPlace ? this : CloneAsDecimalColumn();
-            newColumn.ColumnContainer.Modulo(value);
-            return newColumn;
-        }
-    }
-
-    public partial class DoubleDataFrameColumn
-    {
-        internal DoubleDataFrameColumn ModuloImplementation(double value, bool inPlace = false)
-        {
-            DoubleDataFrameColumn newColumn = inPlace ? this : CloneAsDoubleColumn();
-            newColumn.ColumnContainer.Modulo(value);
-            return newColumn;
-        }
-    }
-
-    public partial class SingleDataFrameColumn
-    {
-        internal SingleDataFrameColumn ModuloImplementation(float value, bool inPlace = false)
-        {
-            SingleDataFrameColumn newColumn = inPlace ? this : CloneAsSingleColumn();
-            newColumn.ColumnContainer.Modulo(value);
-            return newColumn;
-        }
-    }
-
-    public partial class Int32DataFrameColumn
-    {
-        internal Int32DataFrameColumn ModuloImplementation(int value, bool inPlace = false)
-        {
-            Int32DataFrameColumn newColumn = inPlace ? this : CloneAsInt32Column();
-            newColumn.ColumnContainer.Modulo(value);
-            return newColumn;
-        }
-    }
-
-    public partial class Int64DataFrameColumn
-    {
-        internal Int64DataFrameColumn ModuloImplementation(long value, bool inPlace = false)
-        {
-            Int64DataFrameColumn newColumn = inPlace ? this : CloneAsInt64Column();
-            newColumn.ColumnContainer.Modulo(value);
-            return newColumn;
-        }
-    }
-
-    public partial class UInt32DataFrameColumn
-    {
-        internal UInt32DataFrameColumn ModuloImplementation(uint value, bool inPlace = false)
-        {
-            UInt32DataFrameColumn newColumn = inPlace ? this : CloneAsUInt32Column();
-            newColumn.ColumnContainer.Modulo(value);
-            return newColumn;
-        }
-    }
-
-    public partial class UInt64DataFrameColumn
-    {
-        internal UInt64DataFrameColumn ModuloImplementation(ulong value, bool inPlace = false)
-        {
-            UInt64DataFrameColumn newColumn = inPlace ? this : CloneAsUInt64Column();
-            newColumn.ColumnContainer.Modulo(value);
-            return newColumn;
-        }
-    }
-
-    public partial class DecimalDataFrameColumn
-    {
-        internal DecimalDataFrameColumn ReverseModuloImplementation(decimal value, bool inPlace = false)
-        {
-            DecimalDataFrameColumn newColumn = inPlace ? this : CloneAsDecimalColumn();
-            newColumn.ColumnContainer.ReverseModulo(value);
-            return newColumn;
-        }
-    }
-
-    public partial class DoubleDataFrameColumn
-    {
-        internal DoubleDataFrameColumn ReverseModuloImplementation(double value, bool inPlace = false)
-        {
-            DoubleDataFrameColumn newColumn = inPlace ? this : CloneAsDoubleColumn();
-            newColumn.ColumnContainer.ReverseModulo(value);
-            return newColumn;
-        }
-    }
-
-    public partial class SingleDataFrameColumn
-    {
-        internal SingleDataFrameColumn ReverseModuloImplementation(float value, bool inPlace = false)
-        {
-            SingleDataFrameColumn newColumn = inPlace ? this : CloneAsSingleColumn();
-            newColumn.ColumnContainer.ReverseModulo(value);
-            return newColumn;
-        }
-    }
-
-    public partial class Int32DataFrameColumn
-    {
-        internal Int32DataFrameColumn ReverseModuloImplementation(int value, bool inPlace = false)
-        {
-            Int32DataFrameColumn newColumn = inPlace ? this : CloneAsInt32Column();
-            newColumn.ColumnContainer.ReverseModulo(value);
-            return newColumn;
-        }
-    }
-
-    public partial class Int64DataFrameColumn
-    {
-        internal Int64DataFrameColumn ReverseModuloImplementation(long value, bool inPlace = false)
-        {
-            Int64DataFrameColumn newColumn = inPlace ? this : CloneAsInt64Column();
-            newColumn.ColumnContainer.ReverseModulo(value);
-            return newColumn;
-        }
-    }
-
-    public partial class UInt32DataFrameColumn
-    {
-        internal UInt32DataFrameColumn ReverseModuloImplementation(uint value, bool inPlace = false)
-        {
-            UInt32DataFrameColumn newColumn = inPlace ? this : CloneAsUInt32Column();
-            newColumn.ColumnContainer.ReverseModulo(value);
-            return newColumn;
-        }
-    }
-
-    public partial class UInt64DataFrameColumn
-    {
-        internal UInt64DataFrameColumn ReverseModuloImplementation(ulong value, bool inPlace = false)
-        {
-            UInt64DataFrameColumn newColumn = inPlace ? this : CloneAsUInt64Column();
-            newColumn.ColumnContainer.ReverseModulo(value);
-            return newColumn;
-        }
-    }
-
-    public partial class BooleanDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(BooleanDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class ByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(ByteDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class DecimalDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(DecimalDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class DoubleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(DoubleDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class SingleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(SingleDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class Int32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(Int32DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class Int64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(Int64DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class SByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(SByteDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class Int16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(Int16DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class UInt32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(UInt32DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class UInt64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(UInt64DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class UInt16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(UInt16DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class DateTimeDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(DateTimeDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class BooleanDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(bool value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
-        }
-    }
-
-    public partial class ByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(byte value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
-        }
-    }
-
-    public partial class DecimalDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(decimal value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
-        }
-    }
-
-    public partial class DoubleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(double value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
-        }
-    }
-
-    public partial class SingleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(float value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
-        }
-    }
-
-    public partial class Int32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(int value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
-        }
-    }
-
-    public partial class Int64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(long value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
-        }
-    }
-
-    public partial class SByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(sbyte value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
-        }
-    }
-
-    public partial class Int16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(short value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
-        }
-    }
-
-    public partial class UInt32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(uint value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
-        }
-    }
-
-    public partial class UInt64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(ulong value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
-        }
-    }
-
-    public partial class UInt16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(ushort value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
-        }
-    }
-
-    public partial class DateTimeDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseEqualsImplementation(DateTime value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
-        }
-    }
-
-    public partial class BooleanDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(BooleanDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class ByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(ByteDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class DecimalDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(DecimalDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class DoubleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(DoubleDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class SingleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(SingleDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class Int32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(Int32DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class Int64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(Int64DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class SByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(SByteDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class Int16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(Int16DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class UInt32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(UInt32DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class UInt64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(UInt64DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class UInt16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(UInt16DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class DateTimeDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(DateTimeDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
-        }
-    }
-
-    public partial class BooleanDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(bool value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
-        }
-    }
-
-    public partial class ByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(byte value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
-        }
-    }
-
-    public partial class DecimalDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(decimal value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
-        }
-    }
-
-    public partial class DoubleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(double value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
-        }
-    }
-
-    public partial class SingleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(float value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
-        }
-    }
-
-    public partial class Int32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(int value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
-        }
-    }
-
-    public partial class Int64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(long value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
-        }
-    }
-
-    public partial class SByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(sbyte value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
-        }
-    }
-
-    public partial class Int16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(short value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
-        }
-    }
-
-    public partial class UInt32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(uint value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
-        }
-    }
-
-    public partial class UInt64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(ulong value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
-        }
-    }
-
-    public partial class UInt16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(ushort value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
-        }
-    }
-
-    public partial class DateTimeDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(DateTime value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
-        }
-    }
-
-    public partial class BooleanDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(BooleanDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class ByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(ByteDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class DecimalDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(DecimalDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class DoubleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(DoubleDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class SingleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(SingleDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class Int32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(Int32DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class Int64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(Int64DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class SByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(SByteDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class Int16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(Int16DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class UInt32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(UInt32DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class UInt64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(UInt64DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class UInt16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(UInt16DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class DateTimeDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(DateTimeDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class BooleanDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(bool value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
-        }
-    }
-
-    public partial class ByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(byte value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
-        }
-    }
-
-    public partial class DecimalDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(decimal value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
-        }
-    }
-
-    public partial class DoubleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(double value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
-        }
-    }
-
-    public partial class SingleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(float value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
-        }
-    }
-
-    public partial class Int32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(int value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
-        }
-    }
-
-    public partial class Int64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(long value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
-        }
-    }
-
-    public partial class SByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(sbyte value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
-        }
-    }
-
-    public partial class Int16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(short value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
-        }
-    }
-
-    public partial class UInt32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(uint value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
-        }
-    }
-
-    public partial class UInt64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(ulong value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
-        }
-    }
-
-    public partial class UInt16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(ushort value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
-        }
-    }
-
-    public partial class DateTimeDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(DateTime value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
-        }
-    }
-
-    public partial class BooleanDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(BooleanDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class ByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(ByteDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class DecimalDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(DecimalDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class DoubleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(DoubleDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class SingleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(SingleDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class Int32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(Int32DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class Int64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(Int64DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class SByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(SByteDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class Int16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(Int16DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class UInt32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(UInt32DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class UInt64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(UInt64DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class UInt16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(UInt16DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class DateTimeDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(DateTimeDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
-        }
-    }
-
-    public partial class BooleanDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(bool value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
-        }
-    }
-
-    public partial class ByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(byte value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
-        }
-    }
-
-    public partial class DecimalDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(decimal value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
-        }
-    }
-
-    public partial class DoubleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(double value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
-        }
-    }
-
-    public partial class SingleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(float value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
-        }
-    }
-
-    public partial class Int32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(int value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
-        }
-    }
-
-    public partial class Int64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(long value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
-        }
-    }
-
-    public partial class SByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(sbyte value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
-        }
-    }
-
-    public partial class Int16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(short value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
-        }
-    }
-
-    public partial class UInt32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(uint value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
-        }
-    }
-
-    public partial class UInt64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(ulong value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
-        }
-    }
-
-    public partial class UInt16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(ushort value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
-        }
-    }
-
-    public partial class DateTimeDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(DateTime value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
-        }
-    }
-
-    public partial class BooleanDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(BooleanDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class ByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(ByteDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class DecimalDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(DecimalDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class DoubleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(DoubleDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class SingleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(SingleDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class Int32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(Int32DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class Int64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(Int64DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class SByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(SByteDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class Int16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(Int16DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class UInt32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(UInt32DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class UInt64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(UInt64DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class UInt16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(UInt16DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class DateTimeDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(DateTimeDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class BooleanDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(bool value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
-        }
-    }
-
-    public partial class ByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(byte value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
-        }
-    }
-
-    public partial class DecimalDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(decimal value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
-        }
-    }
-
-    public partial class DoubleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(double value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
-        }
-    }
-
-    public partial class SingleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(float value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
-        }
-    }
-
-    public partial class Int32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(int value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
-        }
-    }
-
-    public partial class Int64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(long value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
-        }
-    }
-
-    public partial class SByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(sbyte value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
-        }
-    }
-
-    public partial class Int16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(short value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
-        }
-    }
-
-    public partial class UInt32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(uint value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
-        }
-    }
-
-    public partial class UInt64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(ulong value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
-        }
-    }
-
-    public partial class UInt16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(ushort value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
-        }
-    }
-
-    public partial class DateTimeDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(DateTime value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
-        }
-    }
-
-    public partial class BooleanDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(BooleanDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class ByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(ByteDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class DecimalDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(DecimalDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class DoubleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(DoubleDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class SingleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(SingleDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class Int32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(Int32DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class Int64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(Int64DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class SByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(SByteDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class Int16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(Int16DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class UInt32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(UInt32DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class UInt64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(UInt64DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class UInt16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(UInt16DataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class DateTimeDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(DateTimeDataFrameColumn column)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
-        }
-    }
-
-    public partial class BooleanDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(bool value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
-        }
-    }
-
-    public partial class ByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(byte value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
-        }
-    }
-
-    public partial class DecimalDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(decimal value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
-        }
-    }
-
-    public partial class DoubleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(double value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
-        }
-    }
-
-    public partial class SingleDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(float value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
-        }
-    }
-
-    public partial class Int32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(int value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
-        }
-    }
-
-    public partial class Int64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(long value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
-        }
-    }
-
-    public partial class SByteDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(sbyte value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
-        }
-    }
-
-    public partial class Int16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(short value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
-        }
-    }
-
-    public partial class UInt32DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(uint value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
-        }
-    }
-
-    public partial class UInt64DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(ulong value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
-        }
-    }
-
-    public partial class UInt16DataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(ushort value)
-        {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
-        }
-    }
-
-    public partial class DateTimeDataFrameColumn
-    {
-        internal BooleanDataFrameColumn ElementwiseLessThanImplementation(DateTime value)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, DateTime value)
         {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
     }
 }
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt
index 89eede1a0c..f3dfc830d8 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt
@@ -31,7 +31,7 @@ bool supportedInPlace(string type1, string type2)
 #>
 <# 
 // This method generates implementations where the arguments are of the same type.
-void GenerateAllBinaryCombinationsForMethod(string inputMethodName)
+void GenerateAllBinaryCombinationsForMethods()
 {
  foreach (TypeCombination types in BinaryOperationCombinations.binaryOperationCombinations) 
 { 
@@ -51,23 +51,22 @@ void GenerateAllBinaryCombinationsForMethod(string inputMethodName)
     string fullColumnType = GetCapitalizedPrimitiveTypes(columnType) + "DataFrameColumn";
     string fullReturnType = fullColumnType;
     string fullOtherColumnType = fullColumnType;
-
-    string capitalizedReturnType = GetCapitalizedPrimitiveTypes(returnType);
-    string methodName = inputMethodName + "Implementation";
 #>
+
     public partial class <#=fullColumnType#>
     {
+        //Binary Operations
 <#
     if (supportedInPlace(columnType, otherColumnType))
     {
 #>
-        internal <#=fullReturnType#> <#=methodName#>(<#=fullOtherColumnType#> column, bool inPlace = false)
+        internal <#=fullReturnType#> HandleOperationImplementation(BinaryOperation operation, <#=fullOtherColumnType#> column, bool inPlace = false)
 <#
     }
     else
     {
 #>
-        internal <#=fullReturnType#> <#=methodName#>(<#=fullOtherColumnType#> column)
+        internal <#=fullReturnType#> HandleOperationImplementation(BinaryOperation operation, <#=fullOtherColumnType#> column)
 <#
     }
 #>
@@ -76,62 +75,23 @@ void GenerateAllBinaryCombinationsForMethod(string inputMethodName)
             {
                 throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
             }
-            <#=fullReturnType#> newColumn = inPlace ? this : (<#=fullReturnType#>)Clone();
-            newColumn.ColumnContainer.<#=inputMethodName#>(column.ColumnContainer);
+            var newColumn = inPlace ? this : (<#=fullReturnType#>)Clone();
+            newColumn.ColumnContainer.HandleOperation(operation, column.ColumnContainer);
             return newColumn;
         }
-    }
-<# 
-} 
-}
-#>
-<# 
-// This method generates implementations where the arguments are of the same type.
-void GenerateAllBinaryScalarCombinationsForMethod(string inputMethodName)
-{
- foreach (TypeCombination types in BinaryOperationCombinations.binaryOperationCombinations) 
-{ 
-    string returnType = types.ReturnColumnType;
-    string columnType = types.ThisColumnType;
-    string otherColumnType = types.OtherColumnType;
-    if (columnType != otherColumnType)
-    {
-        continue;
-    }
-    if (columnType != returnType)
-    {
-        continue;
-    }
-    Debug.Assert(returnType == otherColumnType);
-
-    string fullColumnType = GetCapitalizedPrimitiveTypes(columnType) + "DataFrameColumn";
-    string fullReturnType = fullColumnType;
-    string fullOtherColumnType = fullColumnType;
 
-    string capitalizedReturnType = GetCapitalizedPrimitiveTypes(returnType);
-    string methodName = inputMethodName;
-    methodName += "Implementation";
-#>
+        //Binary Scalar Operations
+        internal <#=fullReturnType#> HandleOperationImplementation(BinaryScalarOperation operation, <#=otherColumnType#> right, bool inPlace = false)
+        {
+            var newColumn = inPlace ? this : (<#=fullReturnType#>)Clone();
+            newColumn.ColumnContainer.HandleOperation(operation, right);
+            return newColumn;
+        }
 
-    public partial class <#=fullColumnType#>
-    {
-<#
-    if (supportedInPlace(columnType, otherColumnType))
-    {
-#>
-        internal <#=fullReturnType#> <#=methodName#>(<#=otherColumnType#> value, bool inPlace = false)
-<#
-    }
-    else
-    {
-#>
-        internal <#=fullReturnType#> <#=methodName#>(<#=otherColumnType#> value)
-<#
-    }
-#>
+        internal <#=fullReturnType#> HandleReverseOperationImplementation(BinaryScalarOperation operation, <#=otherColumnType#> right, bool inPlace = false)
         {
-            <#=fullReturnType#> newColumn = inPlace ? this : CloneAs<#=capitalizedReturnType#>Column();
-            newColumn.ColumnContainer.<#=inputMethodName#>(value);
+            var newColumn = inPlace ? this : (<#=fullReturnType#>)Clone();
+            newColumn.ColumnContainer.HandleReverseOperation(operation, right);
             return newColumn;
         }
     }
@@ -140,68 +100,31 @@ void GenerateAllBinaryScalarCombinationsForMethod(string inputMethodName)
 }
 #>
 <# 
-void GenerateAllComparisonCombinationsForMethod(string inputMethodName)
+void GenerateAllComparisonCombinationsForMethods()
 {
  foreach (TypeCombination types in ComparisonOperationCombinations.comparisonOperationCombinations) 
  {
-    string returnType = types.ReturnColumnType;
     string columnType = types.ThisColumnType;
     string otherColumnType = types.OtherColumnType;
     if (columnType != otherColumnType)
     {
         continue;
     }
-    Debug.Assert(returnType == otherColumnType);
-
+    
     string fullColumnType = GetCapitalizedPrimitiveTypes(columnType) + "DataFrameColumn";
-    string fullReturnType = GetCapitalizedPrimitiveTypes(returnType) + "DataFrameColumn";
     string fullOtherColumnType = GetCapitalizedPrimitiveTypes(otherColumnType) + "DataFrameColumn";
-
-    string capitalizedReturnType = GetCapitalizedPrimitiveTypes(returnType);
-    string methodName = inputMethodName;
-    methodName += "Implementation";
-
 #>
 
     public partial class <#=fullColumnType#>
     {
-        internal <#=fullReturnType#> <#=methodName#>(<#=fullOtherColumnType#> column)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, <#=fullOtherColumnType#> column)
         {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.<#=inputMethodName#>(column.ColumnContainer));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
-    }
-<# 
- }
- }
-#>
-<# 
-void GenerateAllComparisonScalarCombinationsForMethod(string inputMethodName)
-{
- foreach (TypeCombination types in ComparisonOperationCombinations.comparisonOperationCombinations) 
- {
-    string returnType = types.ReturnColumnType;
-    string columnType = types.ThisColumnType;
-    string otherColumnType = types.OtherColumnType;
-    if (columnType != otherColumnType)
-    {
-        continue;
-    }
-    Debug.Assert(returnType == otherColumnType);
-
-    string fullColumnType = GetCapitalizedPrimitiveTypes(columnType) + "DataFrameColumn";
-    string fullReturnType = GetCapitalizedPrimitiveTypes(returnType) + "DataFrameColumn";
 
-    string capitalizedReturnType = GetCapitalizedPrimitiveTypes(returnType);
-    string methodName = inputMethodName;
-    methodName += "Implementation";
-
-#>
-
-    public partial class <#=fullColumnType#>
-    {
-        internal <#=fullReturnType#> <#=methodName#>(<#=otherColumnType#> value)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, <#=otherColumnType#> value)
         {
-            return new BooleanDataFrameColumn(Name, ColumnContainer.<#=inputMethodName#>(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
     }
 <# 
@@ -209,26 +132,7 @@ void GenerateAllComparisonScalarCombinationsForMethod(string inputMethodName)
  }
 #>
 <#
-foreach (MethodConfiguration method in methodConfiguration)
-{
-    // Don't generate method for Comparison and ComparisonScalar methods here
-    if (method.MethodType == MethodType.Binary && method.IsNumeric)
-    {
-        GenerateAllBinaryCombinationsForMethod(method.MethodName);
-    }
-    else if (method.MethodType == MethodType.BinaryScalar && method.IsNumeric)
-    {
-        GenerateAllBinaryScalarCombinationsForMethod(method.MethodName);
-        GenerateAllBinaryScalarCombinationsForMethod("Reverse" + method.MethodName);
-    }
-    else if (method.MethodType == MethodType.Comparison)
-    {
-        GenerateAllComparisonCombinationsForMethod(method.MethodName);
-    }
-    else if (method.MethodType == MethodType.ComparisonScalar)
-    {
-        GenerateAllComparisonScalarCombinationsForMethod(method.MethodName);
-    }
-}
+GenerateAllBinaryCombinationsForMethods();
+GenerateAllComparisonCombinationsForMethods();
 #>
 }
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs
index 2b6cde89c0..40e395e61c 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs
@@ -20,33 +20,33 @@ public override DataFrameColumn Add(DataFrameColumn column, bool inPlace = false
             switch (column)
             {
                 case PrimitiveDataFrameColumn<bool> boolColumn:
-                    return AddImplementation(boolColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Add, boolColumn, inPlace);
                 case PrimitiveDataFrameColumn<byte> byteColumn:
-                    return AddImplementation(byteColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Add, byteColumn, inPlace);
                 case PrimitiveDataFrameColumn<char> charColumn:
-                    return AddImplementation(charColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Add, charColumn, inPlace);
                 case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    return AddImplementation(decimalColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Add, decimalColumn, inPlace);
                 case PrimitiveDataFrameColumn<double> doubleColumn:
-                    return AddImplementation(doubleColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Add, doubleColumn, inPlace);
                 case PrimitiveDataFrameColumn<float> floatColumn:
-                    return AddImplementation(floatColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Add, floatColumn, inPlace);
                 case PrimitiveDataFrameColumn<int> intColumn:
-                    return AddImplementation(intColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Add, intColumn, inPlace);
                 case PrimitiveDataFrameColumn<long> longColumn:
-                    return AddImplementation(longColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Add, longColumn, inPlace);
                 case PrimitiveDataFrameColumn<sbyte> sbyteColumn:
-                    return AddImplementation(sbyteColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Add, sbyteColumn, inPlace);
                 case PrimitiveDataFrameColumn<short> shortColumn:
-                    return AddImplementation(shortColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Add, shortColumn, inPlace);
                 case PrimitiveDataFrameColumn<uint> uintColumn:
-                    return AddImplementation(uintColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Add, uintColumn, inPlace);
                 case PrimitiveDataFrameColumn<ulong> ulongColumn:
-                    return AddImplementation(ulongColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Add, ulongColumn, inPlace);
                 case PrimitiveDataFrameColumn<ushort> ushortColumn:
-                    return AddImplementation(ushortColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Add, ushortColumn, inPlace);
                 case PrimitiveDataFrameColumn<DateTime> DateTimeColumn:
-                    return AddImplementation(DateTimeColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Add, DateTimeColumn, inPlace);
 
                 default:
                     throw new NotSupportedException();
@@ -61,42 +61,47 @@ public override DataFrameColumn Add<U>(U value, bool inPlace = false)
             {
                 return Add(column, inPlace);
             }
-            return AddImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
         }
 
+        /// <inheritdoc/>
+        public override DataFrameColumn ReverseAdd<U>(U value, bool inPlace = false)
+        {
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
+        }
         /// <inheritdoc/>
         public override DataFrameColumn Subtract(DataFrameColumn column, bool inPlace = false)
         {
             switch (column)
             {
                 case PrimitiveDataFrameColumn<bool> boolColumn:
-                    return SubtractImplementation(boolColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Subtract, boolColumn, inPlace);
                 case PrimitiveDataFrameColumn<byte> byteColumn:
-                    return SubtractImplementation(byteColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Subtract, byteColumn, inPlace);
                 case PrimitiveDataFrameColumn<char> charColumn:
-                    return SubtractImplementation(charColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Subtract, charColumn, inPlace);
                 case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    return SubtractImplementation(decimalColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Subtract, decimalColumn, inPlace);
                 case PrimitiveDataFrameColumn<double> doubleColumn:
-                    return SubtractImplementation(doubleColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Subtract, doubleColumn, inPlace);
                 case PrimitiveDataFrameColumn<float> floatColumn:
-                    return SubtractImplementation(floatColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Subtract, floatColumn, inPlace);
                 case PrimitiveDataFrameColumn<int> intColumn:
-                    return SubtractImplementation(intColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Subtract, intColumn, inPlace);
                 case PrimitiveDataFrameColumn<long> longColumn:
-                    return SubtractImplementation(longColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Subtract, longColumn, inPlace);
                 case PrimitiveDataFrameColumn<sbyte> sbyteColumn:
-                    return SubtractImplementation(sbyteColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Subtract, sbyteColumn, inPlace);
                 case PrimitiveDataFrameColumn<short> shortColumn:
-                    return SubtractImplementation(shortColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Subtract, shortColumn, inPlace);
                 case PrimitiveDataFrameColumn<uint> uintColumn:
-                    return SubtractImplementation(uintColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Subtract, uintColumn, inPlace);
                 case PrimitiveDataFrameColumn<ulong> ulongColumn:
-                    return SubtractImplementation(ulongColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Subtract, ulongColumn, inPlace);
                 case PrimitiveDataFrameColumn<ushort> ushortColumn:
-                    return SubtractImplementation(ushortColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Subtract, ushortColumn, inPlace);
                 case PrimitiveDataFrameColumn<DateTime> DateTimeColumn:
-                    return SubtractImplementation(DateTimeColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Subtract, DateTimeColumn, inPlace);
 
                 default:
                     throw new NotSupportedException();
@@ -111,42 +116,47 @@ public override DataFrameColumn Subtract<U>(U value, bool inPlace = false)
             {
                 return Subtract(column, inPlace);
             }
-            return SubtractImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
         }
 
+        /// <inheritdoc/>
+        public override DataFrameColumn ReverseSubtract<U>(U value, bool inPlace = false)
+        {
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
+        }
         /// <inheritdoc/>
         public override DataFrameColumn Multiply(DataFrameColumn column, bool inPlace = false)
         {
             switch (column)
             {
                 case PrimitiveDataFrameColumn<bool> boolColumn:
-                    return MultiplyImplementation(boolColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Multiply, boolColumn, inPlace);
                 case PrimitiveDataFrameColumn<byte> byteColumn:
-                    return MultiplyImplementation(byteColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Multiply, byteColumn, inPlace);
                 case PrimitiveDataFrameColumn<char> charColumn:
-                    return MultiplyImplementation(charColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Multiply, charColumn, inPlace);
                 case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    return MultiplyImplementation(decimalColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Multiply, decimalColumn, inPlace);
                 case PrimitiveDataFrameColumn<double> doubleColumn:
-                    return MultiplyImplementation(doubleColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Multiply, doubleColumn, inPlace);
                 case PrimitiveDataFrameColumn<float> floatColumn:
-                    return MultiplyImplementation(floatColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Multiply, floatColumn, inPlace);
                 case PrimitiveDataFrameColumn<int> intColumn:
-                    return MultiplyImplementation(intColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Multiply, intColumn, inPlace);
                 case PrimitiveDataFrameColumn<long> longColumn:
-                    return MultiplyImplementation(longColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Multiply, longColumn, inPlace);
                 case PrimitiveDataFrameColumn<sbyte> sbyteColumn:
-                    return MultiplyImplementation(sbyteColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Multiply, sbyteColumn, inPlace);
                 case PrimitiveDataFrameColumn<short> shortColumn:
-                    return MultiplyImplementation(shortColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Multiply, shortColumn, inPlace);
                 case PrimitiveDataFrameColumn<uint> uintColumn:
-                    return MultiplyImplementation(uintColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Multiply, uintColumn, inPlace);
                 case PrimitiveDataFrameColumn<ulong> ulongColumn:
-                    return MultiplyImplementation(ulongColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Multiply, ulongColumn, inPlace);
                 case PrimitiveDataFrameColumn<ushort> ushortColumn:
-                    return MultiplyImplementation(ushortColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Multiply, ushortColumn, inPlace);
                 case PrimitiveDataFrameColumn<DateTime> DateTimeColumn:
-                    return MultiplyImplementation(DateTimeColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Multiply, DateTimeColumn, inPlace);
 
                 default:
                     throw new NotSupportedException();
@@ -161,42 +171,47 @@ public override DataFrameColumn Multiply<U>(U value, bool inPlace = false)
             {
                 return Multiply(column, inPlace);
             }
-            return MultiplyImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
         }
 
+        /// <inheritdoc/>
+        public override DataFrameColumn ReverseMultiply<U>(U value, bool inPlace = false)
+        {
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
+        }
         /// <inheritdoc/>
         public override DataFrameColumn Divide(DataFrameColumn column, bool inPlace = false)
         {
             switch (column)
             {
                 case PrimitiveDataFrameColumn<bool> boolColumn:
-                    return DivideImplementation(boolColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Divide, boolColumn, inPlace);
                 case PrimitiveDataFrameColumn<byte> byteColumn:
-                    return DivideImplementation(byteColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Divide, byteColumn, inPlace);
                 case PrimitiveDataFrameColumn<char> charColumn:
-                    return DivideImplementation(charColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Divide, charColumn, inPlace);
                 case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    return DivideImplementation(decimalColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Divide, decimalColumn, inPlace);
                 case PrimitiveDataFrameColumn<double> doubleColumn:
-                    return DivideImplementation(doubleColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Divide, doubleColumn, inPlace);
                 case PrimitiveDataFrameColumn<float> floatColumn:
-                    return DivideImplementation(floatColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Divide, floatColumn, inPlace);
                 case PrimitiveDataFrameColumn<int> intColumn:
-                    return DivideImplementation(intColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Divide, intColumn, inPlace);
                 case PrimitiveDataFrameColumn<long> longColumn:
-                    return DivideImplementation(longColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Divide, longColumn, inPlace);
                 case PrimitiveDataFrameColumn<sbyte> sbyteColumn:
-                    return DivideImplementation(sbyteColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Divide, sbyteColumn, inPlace);
                 case PrimitiveDataFrameColumn<short> shortColumn:
-                    return DivideImplementation(shortColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Divide, shortColumn, inPlace);
                 case PrimitiveDataFrameColumn<uint> uintColumn:
-                    return DivideImplementation(uintColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Divide, uintColumn, inPlace);
                 case PrimitiveDataFrameColumn<ulong> ulongColumn:
-                    return DivideImplementation(ulongColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Divide, ulongColumn, inPlace);
                 case PrimitiveDataFrameColumn<ushort> ushortColumn:
-                    return DivideImplementation(ushortColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Divide, ushortColumn, inPlace);
                 case PrimitiveDataFrameColumn<DateTime> DateTimeColumn:
-                    return DivideImplementation(DateTimeColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Divide, DateTimeColumn, inPlace);
 
                 default:
                     throw new NotSupportedException();
@@ -211,42 +226,47 @@ public override DataFrameColumn Divide<U>(U value, bool inPlace = false)
             {
                 return Divide(column, inPlace);
             }
-            return DivideImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
         }
 
+        /// <inheritdoc/>
+        public override DataFrameColumn ReverseDivide<U>(U value, bool inPlace = false)
+        {
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
+        }
         /// <inheritdoc/>
         public override DataFrameColumn Modulo(DataFrameColumn column, bool inPlace = false)
         {
             switch (column)
             {
                 case PrimitiveDataFrameColumn<bool> boolColumn:
-                    return ModuloImplementation(boolColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Modulo, boolColumn, inPlace);
                 case PrimitiveDataFrameColumn<byte> byteColumn:
-                    return ModuloImplementation(byteColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Modulo, byteColumn, inPlace);
                 case PrimitiveDataFrameColumn<char> charColumn:
-                    return ModuloImplementation(charColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Modulo, charColumn, inPlace);
                 case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    return ModuloImplementation(decimalColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Modulo, decimalColumn, inPlace);
                 case PrimitiveDataFrameColumn<double> doubleColumn:
-                    return ModuloImplementation(doubleColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Modulo, doubleColumn, inPlace);
                 case PrimitiveDataFrameColumn<float> floatColumn:
-                    return ModuloImplementation(floatColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Modulo, floatColumn, inPlace);
                 case PrimitiveDataFrameColumn<int> intColumn:
-                    return ModuloImplementation(intColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Modulo, intColumn, inPlace);
                 case PrimitiveDataFrameColumn<long> longColumn:
-                    return ModuloImplementation(longColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Modulo, longColumn, inPlace);
                 case PrimitiveDataFrameColumn<sbyte> sbyteColumn:
-                    return ModuloImplementation(sbyteColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Modulo, sbyteColumn, inPlace);
                 case PrimitiveDataFrameColumn<short> shortColumn:
-                    return ModuloImplementation(shortColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Modulo, shortColumn, inPlace);
                 case PrimitiveDataFrameColumn<uint> uintColumn:
-                    return ModuloImplementation(uintColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Modulo, uintColumn, inPlace);
                 case PrimitiveDataFrameColumn<ulong> ulongColumn:
-                    return ModuloImplementation(ulongColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Modulo, ulongColumn, inPlace);
                 case PrimitiveDataFrameColumn<ushort> ushortColumn:
-                    return ModuloImplementation(ushortColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Modulo, ushortColumn, inPlace);
                 case PrimitiveDataFrameColumn<DateTime> DateTimeColumn:
-                    return ModuloImplementation(DateTimeColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Modulo, DateTimeColumn, inPlace);
 
                 default:
                     throw new NotSupportedException();
@@ -261,42 +281,47 @@ public override DataFrameColumn Modulo<U>(U value, bool inPlace = false)
             {
                 return Modulo(column, inPlace);
             }
-            return ModuloImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
         }
 
+        /// <inheritdoc/>
+        public override DataFrameColumn ReverseModulo<U>(U value, bool inPlace = false)
+        {
+            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
+        }
         /// <inheritdoc/>
         public override DataFrameColumn And(DataFrameColumn column, bool inPlace = false)
         {
             switch (column)
             {
                 case PrimitiveDataFrameColumn<bool> boolColumn:
-                    return AndImplementation(boolColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.And, boolColumn, inPlace);
                 case PrimitiveDataFrameColumn<byte> byteColumn:
-                    return AndImplementation(byteColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.And, byteColumn, inPlace);
                 case PrimitiveDataFrameColumn<char> charColumn:
-                    return AndImplementation(charColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.And, charColumn, inPlace);
                 case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    return AndImplementation(decimalColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.And, decimalColumn, inPlace);
                 case PrimitiveDataFrameColumn<double> doubleColumn:
-                    return AndImplementation(doubleColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.And, doubleColumn, inPlace);
                 case PrimitiveDataFrameColumn<float> floatColumn:
-                    return AndImplementation(floatColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.And, floatColumn, inPlace);
                 case PrimitiveDataFrameColumn<int> intColumn:
-                    return AndImplementation(intColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.And, intColumn, inPlace);
                 case PrimitiveDataFrameColumn<long> longColumn:
-                    return AndImplementation(longColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.And, longColumn, inPlace);
                 case PrimitiveDataFrameColumn<sbyte> sbyteColumn:
-                    return AndImplementation(sbyteColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.And, sbyteColumn, inPlace);
                 case PrimitiveDataFrameColumn<short> shortColumn:
-                    return AndImplementation(shortColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.And, shortColumn, inPlace);
                 case PrimitiveDataFrameColumn<uint> uintColumn:
-                    return AndImplementation(uintColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.And, uintColumn, inPlace);
                 case PrimitiveDataFrameColumn<ulong> ulongColumn:
-                    return AndImplementation(ulongColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.And, ulongColumn, inPlace);
                 case PrimitiveDataFrameColumn<ushort> ushortColumn:
-                    return AndImplementation(ushortColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.And, ushortColumn, inPlace);
                 case PrimitiveDataFrameColumn<DateTime> DateTimeColumn:
-                    return AndImplementation(DateTimeColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.And, DateTimeColumn, inPlace);
 
                 default:
                     throw new NotSupportedException();
@@ -306,42 +331,41 @@ public override DataFrameColumn And(DataFrameColumn column, bool inPlace = false
         /// <inheritdoc/>
         public override PrimitiveDataFrameColumn<bool> And(bool value, bool inPlace = false)
         {
-            return AndImplementation(value, inPlace);
+            return HandleBitwiseOperationImplementation(BinaryScalarOperation.And, value, inPlace);
         }
-
         /// <inheritdoc/>
         public override DataFrameColumn Or(DataFrameColumn column, bool inPlace = false)
         {
             switch (column)
             {
                 case PrimitiveDataFrameColumn<bool> boolColumn:
-                    return OrImplementation(boolColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Or, boolColumn, inPlace);
                 case PrimitiveDataFrameColumn<byte> byteColumn:
-                    return OrImplementation(byteColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Or, byteColumn, inPlace);
                 case PrimitiveDataFrameColumn<char> charColumn:
-                    return OrImplementation(charColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Or, charColumn, inPlace);
                 case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    return OrImplementation(decimalColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Or, decimalColumn, inPlace);
                 case PrimitiveDataFrameColumn<double> doubleColumn:
-                    return OrImplementation(doubleColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Or, doubleColumn, inPlace);
                 case PrimitiveDataFrameColumn<float> floatColumn:
-                    return OrImplementation(floatColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Or, floatColumn, inPlace);
                 case PrimitiveDataFrameColumn<int> intColumn:
-                    return OrImplementation(intColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Or, intColumn, inPlace);
                 case PrimitiveDataFrameColumn<long> longColumn:
-                    return OrImplementation(longColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Or, longColumn, inPlace);
                 case PrimitiveDataFrameColumn<sbyte> sbyteColumn:
-                    return OrImplementation(sbyteColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Or, sbyteColumn, inPlace);
                 case PrimitiveDataFrameColumn<short> shortColumn:
-                    return OrImplementation(shortColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Or, shortColumn, inPlace);
                 case PrimitiveDataFrameColumn<uint> uintColumn:
-                    return OrImplementation(uintColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Or, uintColumn, inPlace);
                 case PrimitiveDataFrameColumn<ulong> ulongColumn:
-                    return OrImplementation(ulongColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Or, ulongColumn, inPlace);
                 case PrimitiveDataFrameColumn<ushort> ushortColumn:
-                    return OrImplementation(ushortColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Or, ushortColumn, inPlace);
                 case PrimitiveDataFrameColumn<DateTime> DateTimeColumn:
-                    return OrImplementation(DateTimeColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Or, DateTimeColumn, inPlace);
 
                 default:
                     throw new NotSupportedException();
@@ -351,42 +375,41 @@ public override DataFrameColumn Or(DataFrameColumn column, bool inPlace = false)
         /// <inheritdoc/>
         public override PrimitiveDataFrameColumn<bool> Or(bool value, bool inPlace = false)
         {
-            return OrImplementation(value, inPlace);
+            return HandleBitwiseOperationImplementation(BinaryScalarOperation.Or, value, inPlace);
         }
-
         /// <inheritdoc/>
         public override DataFrameColumn Xor(DataFrameColumn column, bool inPlace = false)
         {
             switch (column)
             {
                 case PrimitiveDataFrameColumn<bool> boolColumn:
-                    return XorImplementation(boolColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Xor, boolColumn, inPlace);
                 case PrimitiveDataFrameColumn<byte> byteColumn:
-                    return XorImplementation(byteColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Xor, byteColumn, inPlace);
                 case PrimitiveDataFrameColumn<char> charColumn:
-                    return XorImplementation(charColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Xor, charColumn, inPlace);
                 case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    return XorImplementation(decimalColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Xor, decimalColumn, inPlace);
                 case PrimitiveDataFrameColumn<double> doubleColumn:
-                    return XorImplementation(doubleColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Xor, doubleColumn, inPlace);
                 case PrimitiveDataFrameColumn<float> floatColumn:
-                    return XorImplementation(floatColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Xor, floatColumn, inPlace);
                 case PrimitiveDataFrameColumn<int> intColumn:
-                    return XorImplementation(intColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Xor, intColumn, inPlace);
                 case PrimitiveDataFrameColumn<long> longColumn:
-                    return XorImplementation(longColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Xor, longColumn, inPlace);
                 case PrimitiveDataFrameColumn<sbyte> sbyteColumn:
-                    return XorImplementation(sbyteColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Xor, sbyteColumn, inPlace);
                 case PrimitiveDataFrameColumn<short> shortColumn:
-                    return XorImplementation(shortColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Xor, shortColumn, inPlace);
                 case PrimitiveDataFrameColumn<uint> uintColumn:
-                    return XorImplementation(uintColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Xor, uintColumn, inPlace);
                 case PrimitiveDataFrameColumn<ulong> ulongColumn:
-                    return XorImplementation(ulongColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Xor, ulongColumn, inPlace);
                 case PrimitiveDataFrameColumn<ushort> ushortColumn:
-                    return XorImplementation(ushortColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Xor, ushortColumn, inPlace);
                 case PrimitiveDataFrameColumn<DateTime> DateTimeColumn:
-                    return XorImplementation(DateTimeColumn, inPlace);
+                    return HandleOperationImplementation(BinaryOperation.Xor, DateTimeColumn, inPlace);
 
                 default:
                     throw new NotSupportedException();
@@ -396,52 +419,54 @@ public override DataFrameColumn Xor(DataFrameColumn column, bool inPlace = false
         /// <inheritdoc/>
         public override PrimitiveDataFrameColumn<bool> Xor(bool value, bool inPlace = false)
         {
-            return XorImplementation(value, inPlace);
+            return HandleBitwiseOperationImplementation(BinaryScalarOperation.Xor, value, inPlace);
         }
 
         /// <inheritdoc/>
         public override DataFrameColumn LeftShift(int value, bool inPlace = false)
         {
-            return LeftShiftImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryIntOperation.LeftShift, value, inPlace);
         }
+
         /// <inheritdoc/>
         public override DataFrameColumn RightShift(int value, bool inPlace = false)
         {
-            return RightShiftImplementation(value, inPlace);
+            return HandleOperationImplementation(BinaryIntOperation.RightShift, value, inPlace);
         }
+
         /// <inheritdoc/>
         public override PrimitiveDataFrameColumn<bool> ElementwiseEquals(DataFrameColumn column)
         {
             switch (column)
             {
                 case PrimitiveDataFrameColumn<bool> boolColumn:
-                    return ElementwiseEqualsImplementation(boolColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, boolColumn);
                 case PrimitiveDataFrameColumn<byte> byteColumn:
-                    return ElementwiseEqualsImplementation(byteColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, byteColumn);
                 case PrimitiveDataFrameColumn<char> charColumn:
-                    return ElementwiseEqualsImplementation(charColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, charColumn);
                 case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    return ElementwiseEqualsImplementation(decimalColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, decimalColumn);
                 case PrimitiveDataFrameColumn<double> doubleColumn:
-                    return ElementwiseEqualsImplementation(doubleColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, doubleColumn);
                 case PrimitiveDataFrameColumn<float> floatColumn:
-                    return ElementwiseEqualsImplementation(floatColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, floatColumn);
                 case PrimitiveDataFrameColumn<int> intColumn:
-                    return ElementwiseEqualsImplementation(intColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, intColumn);
                 case PrimitiveDataFrameColumn<long> longColumn:
-                    return ElementwiseEqualsImplementation(longColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, longColumn);
                 case PrimitiveDataFrameColumn<sbyte> sbyteColumn:
-                    return ElementwiseEqualsImplementation(sbyteColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, sbyteColumn);
                 case PrimitiveDataFrameColumn<short> shortColumn:
-                    return ElementwiseEqualsImplementation(shortColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, shortColumn);
                 case PrimitiveDataFrameColumn<uint> uintColumn:
-                    return ElementwiseEqualsImplementation(uintColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, uintColumn);
                 case PrimitiveDataFrameColumn<ulong> ulongColumn:
-                    return ElementwiseEqualsImplementation(ulongColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, ulongColumn);
                 case PrimitiveDataFrameColumn<ushort> ushortColumn:
-                    return ElementwiseEqualsImplementation(ushortColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, ushortColumn);
                 case PrimitiveDataFrameColumn<DateTime> DateTimeColumn:
-                    return ElementwiseEqualsImplementation(DateTimeColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, DateTimeColumn);
                 case null:
                     return ElementwiseIsNull();
 
@@ -458,7 +483,7 @@ public override PrimitiveDataFrameColumn<bool> ElementwiseEquals<U>(U value)
             {
                 return ElementwiseEquals(column);
             }
-            return ElementwiseEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
         }
 
         /// <inheritdoc/>
@@ -467,33 +492,33 @@ public override PrimitiveDataFrameColumn<bool> ElementwiseNotEquals(DataFrameCol
             switch (column)
             {
                 case PrimitiveDataFrameColumn<bool> boolColumn:
-                    return ElementwiseNotEqualsImplementation(boolColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, boolColumn);
                 case PrimitiveDataFrameColumn<byte> byteColumn:
-                    return ElementwiseNotEqualsImplementation(byteColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, byteColumn);
                 case PrimitiveDataFrameColumn<char> charColumn:
-                    return ElementwiseNotEqualsImplementation(charColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, charColumn);
                 case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    return ElementwiseNotEqualsImplementation(decimalColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, decimalColumn);
                 case PrimitiveDataFrameColumn<double> doubleColumn:
-                    return ElementwiseNotEqualsImplementation(doubleColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, doubleColumn);
                 case PrimitiveDataFrameColumn<float> floatColumn:
-                    return ElementwiseNotEqualsImplementation(floatColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, floatColumn);
                 case PrimitiveDataFrameColumn<int> intColumn:
-                    return ElementwiseNotEqualsImplementation(intColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, intColumn);
                 case PrimitiveDataFrameColumn<long> longColumn:
-                    return ElementwiseNotEqualsImplementation(longColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, longColumn);
                 case PrimitiveDataFrameColumn<sbyte> sbyteColumn:
-                    return ElementwiseNotEqualsImplementation(sbyteColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, sbyteColumn);
                 case PrimitiveDataFrameColumn<short> shortColumn:
-                    return ElementwiseNotEqualsImplementation(shortColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, shortColumn);
                 case PrimitiveDataFrameColumn<uint> uintColumn:
-                    return ElementwiseNotEqualsImplementation(uintColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, uintColumn);
                 case PrimitiveDataFrameColumn<ulong> ulongColumn:
-                    return ElementwiseNotEqualsImplementation(ulongColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, ulongColumn);
                 case PrimitiveDataFrameColumn<ushort> ushortColumn:
-                    return ElementwiseNotEqualsImplementation(ushortColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, ushortColumn);
                 case PrimitiveDataFrameColumn<DateTime> DateTimeColumn:
-                    return ElementwiseNotEqualsImplementation(DateTimeColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, DateTimeColumn);
                 case null:
                     return ElementwiseIsNotNull();
 
@@ -510,7 +535,7 @@ public override PrimitiveDataFrameColumn<bool> ElementwiseNotEquals<U>(U value)
             {
                 return ElementwiseNotEquals(column);
             }
-            return ElementwiseNotEqualsImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
         }
 
         /// <inheritdoc/>
@@ -519,33 +544,33 @@ public override PrimitiveDataFrameColumn<bool> ElementwiseGreaterThanOrEqual(Dat
             switch (column)
             {
                 case PrimitiveDataFrameColumn<bool> boolColumn:
-                    return ElementwiseGreaterThanOrEqualImplementation(boolColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, boolColumn);
                 case PrimitiveDataFrameColumn<byte> byteColumn:
-                    return ElementwiseGreaterThanOrEqualImplementation(byteColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, byteColumn);
                 case PrimitiveDataFrameColumn<char> charColumn:
-                    return ElementwiseGreaterThanOrEqualImplementation(charColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, charColumn);
                 case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    return ElementwiseGreaterThanOrEqualImplementation(decimalColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, decimalColumn);
                 case PrimitiveDataFrameColumn<double> doubleColumn:
-                    return ElementwiseGreaterThanOrEqualImplementation(doubleColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, doubleColumn);
                 case PrimitiveDataFrameColumn<float> floatColumn:
-                    return ElementwiseGreaterThanOrEqualImplementation(floatColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, floatColumn);
                 case PrimitiveDataFrameColumn<int> intColumn:
-                    return ElementwiseGreaterThanOrEqualImplementation(intColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, intColumn);
                 case PrimitiveDataFrameColumn<long> longColumn:
-                    return ElementwiseGreaterThanOrEqualImplementation(longColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, longColumn);
                 case PrimitiveDataFrameColumn<sbyte> sbyteColumn:
-                    return ElementwiseGreaterThanOrEqualImplementation(sbyteColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, sbyteColumn);
                 case PrimitiveDataFrameColumn<short> shortColumn:
-                    return ElementwiseGreaterThanOrEqualImplementation(shortColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, shortColumn);
                 case PrimitiveDataFrameColumn<uint> uintColumn:
-                    return ElementwiseGreaterThanOrEqualImplementation(uintColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, uintColumn);
                 case PrimitiveDataFrameColumn<ulong> ulongColumn:
-                    return ElementwiseGreaterThanOrEqualImplementation(ulongColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, ulongColumn);
                 case PrimitiveDataFrameColumn<ushort> ushortColumn:
-                    return ElementwiseGreaterThanOrEqualImplementation(ushortColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, ushortColumn);
                 case PrimitiveDataFrameColumn<DateTime> DateTimeColumn:
-                    return ElementwiseGreaterThanOrEqualImplementation(DateTimeColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, DateTimeColumn);
 
                 default:
                     throw new NotSupportedException();
@@ -560,7 +585,7 @@ public override PrimitiveDataFrameColumn<bool> ElementwiseGreaterThanOrEqual<U>(
             {
                 return ElementwiseGreaterThanOrEqual(column);
             }
-            return ElementwiseGreaterThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
         }
 
         /// <inheritdoc/>
@@ -569,33 +594,33 @@ public override PrimitiveDataFrameColumn<bool> ElementwiseLessThanOrEqual(DataFr
             switch (column)
             {
                 case PrimitiveDataFrameColumn<bool> boolColumn:
-                    return ElementwiseLessThanOrEqualImplementation(boolColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, boolColumn);
                 case PrimitiveDataFrameColumn<byte> byteColumn:
-                    return ElementwiseLessThanOrEqualImplementation(byteColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, byteColumn);
                 case PrimitiveDataFrameColumn<char> charColumn:
-                    return ElementwiseLessThanOrEqualImplementation(charColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, charColumn);
                 case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    return ElementwiseLessThanOrEqualImplementation(decimalColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, decimalColumn);
                 case PrimitiveDataFrameColumn<double> doubleColumn:
-                    return ElementwiseLessThanOrEqualImplementation(doubleColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, doubleColumn);
                 case PrimitiveDataFrameColumn<float> floatColumn:
-                    return ElementwiseLessThanOrEqualImplementation(floatColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, floatColumn);
                 case PrimitiveDataFrameColumn<int> intColumn:
-                    return ElementwiseLessThanOrEqualImplementation(intColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, intColumn);
                 case PrimitiveDataFrameColumn<long> longColumn:
-                    return ElementwiseLessThanOrEqualImplementation(longColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, longColumn);
                 case PrimitiveDataFrameColumn<sbyte> sbyteColumn:
-                    return ElementwiseLessThanOrEqualImplementation(sbyteColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, sbyteColumn);
                 case PrimitiveDataFrameColumn<short> shortColumn:
-                    return ElementwiseLessThanOrEqualImplementation(shortColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, shortColumn);
                 case PrimitiveDataFrameColumn<uint> uintColumn:
-                    return ElementwiseLessThanOrEqualImplementation(uintColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, uintColumn);
                 case PrimitiveDataFrameColumn<ulong> ulongColumn:
-                    return ElementwiseLessThanOrEqualImplementation(ulongColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, ulongColumn);
                 case PrimitiveDataFrameColumn<ushort> ushortColumn:
-                    return ElementwiseLessThanOrEqualImplementation(ushortColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, ushortColumn);
                 case PrimitiveDataFrameColumn<DateTime> DateTimeColumn:
-                    return ElementwiseLessThanOrEqualImplementation(DateTimeColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, DateTimeColumn);
 
                 default:
                     throw new NotSupportedException();
@@ -610,7 +635,7 @@ public override PrimitiveDataFrameColumn<bool> ElementwiseLessThanOrEqual<U>(U v
             {
                 return ElementwiseLessThanOrEqual(column);
             }
-            return ElementwiseLessThanOrEqualImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
         }
 
         /// <inheritdoc/>
@@ -619,33 +644,33 @@ public override PrimitiveDataFrameColumn<bool> ElementwiseGreaterThan(DataFrameC
             switch (column)
             {
                 case PrimitiveDataFrameColumn<bool> boolColumn:
-                    return ElementwiseGreaterThanImplementation(boolColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, boolColumn);
                 case PrimitiveDataFrameColumn<byte> byteColumn:
-                    return ElementwiseGreaterThanImplementation(byteColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, byteColumn);
                 case PrimitiveDataFrameColumn<char> charColumn:
-                    return ElementwiseGreaterThanImplementation(charColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, charColumn);
                 case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    return ElementwiseGreaterThanImplementation(decimalColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, decimalColumn);
                 case PrimitiveDataFrameColumn<double> doubleColumn:
-                    return ElementwiseGreaterThanImplementation(doubleColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, doubleColumn);
                 case PrimitiveDataFrameColumn<float> floatColumn:
-                    return ElementwiseGreaterThanImplementation(floatColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, floatColumn);
                 case PrimitiveDataFrameColumn<int> intColumn:
-                    return ElementwiseGreaterThanImplementation(intColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, intColumn);
                 case PrimitiveDataFrameColumn<long> longColumn:
-                    return ElementwiseGreaterThanImplementation(longColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, longColumn);
                 case PrimitiveDataFrameColumn<sbyte> sbyteColumn:
-                    return ElementwiseGreaterThanImplementation(sbyteColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, sbyteColumn);
                 case PrimitiveDataFrameColumn<short> shortColumn:
-                    return ElementwiseGreaterThanImplementation(shortColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, shortColumn);
                 case PrimitiveDataFrameColumn<uint> uintColumn:
-                    return ElementwiseGreaterThanImplementation(uintColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, uintColumn);
                 case PrimitiveDataFrameColumn<ulong> ulongColumn:
-                    return ElementwiseGreaterThanImplementation(ulongColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, ulongColumn);
                 case PrimitiveDataFrameColumn<ushort> ushortColumn:
-                    return ElementwiseGreaterThanImplementation(ushortColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, ushortColumn);
                 case PrimitiveDataFrameColumn<DateTime> DateTimeColumn:
-                    return ElementwiseGreaterThanImplementation(DateTimeColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, DateTimeColumn);
 
                 default:
                     throw new NotSupportedException();
@@ -660,7 +685,7 @@ public override PrimitiveDataFrameColumn<bool> ElementwiseGreaterThan<U>(U value
             {
                 return ElementwiseGreaterThan(column);
             }
-            return ElementwiseGreaterThanImplementation(value);
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
         }
 
         /// <inheritdoc/>
@@ -669,33 +694,33 @@ public override PrimitiveDataFrameColumn<bool> ElementwiseLessThan(DataFrameColu
             switch (column)
             {
                 case PrimitiveDataFrameColumn<bool> boolColumn:
-                    return ElementwiseLessThanImplementation(boolColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, boolColumn);
                 case PrimitiveDataFrameColumn<byte> byteColumn:
-                    return ElementwiseLessThanImplementation(byteColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, byteColumn);
                 case PrimitiveDataFrameColumn<char> charColumn:
-                    return ElementwiseLessThanImplementation(charColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, charColumn);
                 case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    return ElementwiseLessThanImplementation(decimalColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, decimalColumn);
                 case PrimitiveDataFrameColumn<double> doubleColumn:
-                    return ElementwiseLessThanImplementation(doubleColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, doubleColumn);
                 case PrimitiveDataFrameColumn<float> floatColumn:
-                    return ElementwiseLessThanImplementation(floatColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, floatColumn);
                 case PrimitiveDataFrameColumn<int> intColumn:
-                    return ElementwiseLessThanImplementation(intColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, intColumn);
                 case PrimitiveDataFrameColumn<long> longColumn:
-                    return ElementwiseLessThanImplementation(longColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, longColumn);
                 case PrimitiveDataFrameColumn<sbyte> sbyteColumn:
-                    return ElementwiseLessThanImplementation(sbyteColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, sbyteColumn);
                 case PrimitiveDataFrameColumn<short> shortColumn:
-                    return ElementwiseLessThanImplementation(shortColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, shortColumn);
                 case PrimitiveDataFrameColumn<uint> uintColumn:
-                    return ElementwiseLessThanImplementation(uintColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, uintColumn);
                 case PrimitiveDataFrameColumn<ulong> ulongColumn:
-                    return ElementwiseLessThanImplementation(ulongColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, ulongColumn);
                 case PrimitiveDataFrameColumn<ushort> ushortColumn:
-                    return ElementwiseLessThanImplementation(ushortColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, ushortColumn);
                 case PrimitiveDataFrameColumn<DateTime> DateTimeColumn:
-                    return ElementwiseLessThanImplementation(DateTimeColumn);
+                    return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, DateTimeColumn);
 
                 default:
                     throw new NotSupportedException();
@@ -710,1960 +735,8 @@ public override PrimitiveDataFrameColumn<bool> ElementwiseLessThan<U>(U value)
             {
                 return ElementwiseLessThan(column);
             }
-            return ElementwiseLessThanImplementation(value);
-        }
-
-
-        internal DataFrameColumn AddImplementation<U>(PrimitiveDataFrameColumn<U> column, bool inPlace)
-            where U : unmanaged
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<U> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Add(column._columnContainer);
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedColumnValueType, typeof(T)), nameof(column));
-                        }
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.Add(column.CloneAsDecimalColumn()._columnContainer);
-                        return decimalColumn;
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<U> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Add(column._columnContainer);
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedColumnValueType, typeof(T)), nameof(column));
-                        }
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.Add((column as PrimitiveDataFrameColumn<decimal>)._columnContainer);
-                            return decimalColumn;
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.Add(column.CloneAsDoubleColumn()._columnContainer);
-                            return doubleColumn;
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal DataFrameColumn AddImplementation<U>(U value, bool inPlace)
-        {
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Add(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.Add(DecimalConverter<U>.Instance.GetDecimal(value));
-                        return decimalColumn;
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Add(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.Add(DecimalConverter<U>.Instance.GetDecimal(value));
-                            return decimalColumn;
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.Add(DoubleConverter<U>.Instance.GetDouble(value));
-                            return doubleColumn;
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal DataFrameColumn SubtractImplementation<U>(PrimitiveDataFrameColumn<U> column, bool inPlace)
-            where U : unmanaged
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<U> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Subtract(column._columnContainer);
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedColumnValueType, typeof(T)), nameof(column));
-                        }
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.Subtract(column.CloneAsDecimalColumn()._columnContainer);
-                        return decimalColumn;
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<U> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Subtract(column._columnContainer);
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedColumnValueType, typeof(T)), nameof(column));
-                        }
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.Subtract((column as PrimitiveDataFrameColumn<decimal>)._columnContainer);
-                            return decimalColumn;
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.Subtract(column.CloneAsDoubleColumn()._columnContainer);
-                            return doubleColumn;
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal DataFrameColumn SubtractImplementation<U>(U value, bool inPlace)
-        {
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Subtract(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.Subtract(DecimalConverter<U>.Instance.GetDecimal(value));
-                        return decimalColumn;
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Subtract(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.Subtract(DecimalConverter<U>.Instance.GetDecimal(value));
-                            return decimalColumn;
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.Subtract(DoubleConverter<U>.Instance.GetDouble(value));
-                            return doubleColumn;
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal DataFrameColumn MultiplyImplementation<U>(PrimitiveDataFrameColumn<U> column, bool inPlace)
-            where U : unmanaged
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<U> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Multiply(column._columnContainer);
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedColumnValueType, typeof(T)), nameof(column));
-                        }
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.Multiply(column.CloneAsDecimalColumn()._columnContainer);
-                        return decimalColumn;
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<U> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Multiply(column._columnContainer);
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedColumnValueType, typeof(T)), nameof(column));
-                        }
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.Multiply((column as PrimitiveDataFrameColumn<decimal>)._columnContainer);
-                            return decimalColumn;
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.Multiply(column.CloneAsDoubleColumn()._columnContainer);
-                            return doubleColumn;
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal DataFrameColumn MultiplyImplementation<U>(U value, bool inPlace)
-        {
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Multiply(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.Multiply(DecimalConverter<U>.Instance.GetDecimal(value));
-                        return decimalColumn;
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Multiply(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.Multiply(DecimalConverter<U>.Instance.GetDecimal(value));
-                            return decimalColumn;
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.Multiply(DoubleConverter<U>.Instance.GetDouble(value));
-                            return doubleColumn;
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal DataFrameColumn DivideImplementation<U>(PrimitiveDataFrameColumn<U> column, bool inPlace)
-            where U : unmanaged
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<U> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Divide(column._columnContainer);
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedColumnValueType, typeof(T)), nameof(column));
-                        }
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.Divide(column.CloneAsDecimalColumn()._columnContainer);
-                        return decimalColumn;
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<U> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Divide(column._columnContainer);
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedColumnValueType, typeof(T)), nameof(column));
-                        }
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.Divide((column as PrimitiveDataFrameColumn<decimal>)._columnContainer);
-                            return decimalColumn;
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.Divide(column.CloneAsDoubleColumn()._columnContainer);
-                            return doubleColumn;
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal DataFrameColumn DivideImplementation<U>(U value, bool inPlace)
-        {
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Divide(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.Divide(DecimalConverter<U>.Instance.GetDecimal(value));
-                        return decimalColumn;
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Divide(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.Divide(DecimalConverter<U>.Instance.GetDecimal(value));
-                            return decimalColumn;
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.Divide(DoubleConverter<U>.Instance.GetDouble(value));
-                            return doubleColumn;
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal DataFrameColumn ModuloImplementation<U>(PrimitiveDataFrameColumn<U> column, bool inPlace)
-            where U : unmanaged
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<U> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Modulo(column._columnContainer);
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedColumnValueType, typeof(T)), nameof(column));
-                        }
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.Modulo(column.CloneAsDecimalColumn()._columnContainer);
-                        return decimalColumn;
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<U> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Modulo(column._columnContainer);
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedColumnValueType, typeof(T)), nameof(column));
-                        }
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.Modulo((column as PrimitiveDataFrameColumn<decimal>)._columnContainer);
-                            return decimalColumn;
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.Modulo(column.CloneAsDoubleColumn()._columnContainer);
-                            return doubleColumn;
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal DataFrameColumn ModuloImplementation<U>(U value, bool inPlace)
-        {
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Modulo(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.Modulo(DecimalConverter<U>.Instance.GetDecimal(value));
-                        return decimalColumn;
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
-                        newColumn._columnContainer.Modulo(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.Modulo(DecimalConverter<U>.Instance.GetDecimal(value));
-                            return decimalColumn;
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.Modulo(DoubleConverter<U>.Instance.GetDouble(value));
-                            return doubleColumn;
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal DataFrameColumn AndImplementation<U>(PrimitiveDataFrameColumn<U> column, bool inPlace)
-            where U : unmanaged
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    if (typeof(U) != typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    PrimitiveDataFrameColumn<U> typedColumn = this as PrimitiveDataFrameColumn<U>;
-                    PrimitiveDataFrameColumn<U> retColumn = inPlace ? typedColumn : typedColumn.Clone();
-                    retColumn._columnContainer.And(column._columnContainer);
-                    return retColumn;
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type decimalType when decimalType == typeof(decimal):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal PrimitiveDataFrameColumn<bool> AndImplementation<U>(U value, bool inPlace)
-        {
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    if (typeof(U) != typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    PrimitiveDataFrameColumn<bool> typedColumn = this as PrimitiveDataFrameColumn<bool>;
-                    PrimitiveDataFrameColumn<bool> retColumn = inPlace ? typedColumn : typedColumn.Clone();
-                    retColumn._columnContainer.And(Unsafe.As<U, bool>(ref value));
-                    return retColumn as PrimitiveDataFrameColumn<bool>;
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type decimalType when decimalType == typeof(decimal):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal DataFrameColumn OrImplementation<U>(PrimitiveDataFrameColumn<U> column, bool inPlace)
-            where U : unmanaged
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    if (typeof(U) != typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    PrimitiveDataFrameColumn<U> typedColumn = this as PrimitiveDataFrameColumn<U>;
-                    PrimitiveDataFrameColumn<U> retColumn = inPlace ? typedColumn : typedColumn.Clone();
-                    retColumn._columnContainer.Or(column._columnContainer);
-                    return retColumn;
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type decimalType when decimalType == typeof(decimal):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal PrimitiveDataFrameColumn<bool> OrImplementation<U>(U value, bool inPlace)
-        {
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    if (typeof(U) != typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    PrimitiveDataFrameColumn<bool> typedColumn = this as PrimitiveDataFrameColumn<bool>;
-                    PrimitiveDataFrameColumn<bool> retColumn = inPlace ? typedColumn : typedColumn.Clone();
-                    retColumn._columnContainer.Or(Unsafe.As<U, bool>(ref value));
-                    return retColumn as PrimitiveDataFrameColumn<bool>;
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type decimalType when decimalType == typeof(decimal):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                default:
-                    throw new NotSupportedException();
-            }
+            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
         }
 
-        internal DataFrameColumn XorImplementation<U>(PrimitiveDataFrameColumn<U> column, bool inPlace)
-            where U : unmanaged
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    if (typeof(U) != typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    PrimitiveDataFrameColumn<U> typedColumn = this as PrimitiveDataFrameColumn<U>;
-                    PrimitiveDataFrameColumn<U> retColumn = inPlace ? typedColumn : typedColumn.Clone();
-                    retColumn._columnContainer.Xor(column._columnContainer);
-                    return retColumn;
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type decimalType when decimalType == typeof(decimal):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal PrimitiveDataFrameColumn<bool> XorImplementation<U>(U value, bool inPlace)
-        {
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    if (typeof(U) != typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    PrimitiveDataFrameColumn<bool> typedColumn = this as PrimitiveDataFrameColumn<bool>;
-                    PrimitiveDataFrameColumn<bool> retColumn = inPlace ? typedColumn : typedColumn.Clone();
-                    retColumn._columnContainer.Xor(Unsafe.As<U, bool>(ref value));
-                    return retColumn as PrimitiveDataFrameColumn<bool>;
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type decimalType when decimalType == typeof(decimal):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal DataFrameColumn LeftShiftImplementation(int value, bool inPlace)
-        {
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                    PrimitiveDataFrameColumn<byte> byteColumn = this as PrimitiveDataFrameColumn<byte>;
-                    PrimitiveDataFrameColumn<byte> newbyteColumn = inPlace ? byteColumn : byteColumn.Clone();
-                    newbyteColumn._columnContainer.LeftShift(value);
-                    return newbyteColumn;
-                case Type charType when charType == typeof(char):
-                    PrimitiveDataFrameColumn<char> charColumn = this as PrimitiveDataFrameColumn<char>;
-                    PrimitiveDataFrameColumn<char> newcharColumn = inPlace ? charColumn : charColumn.Clone();
-                    newcharColumn._columnContainer.LeftShift(value);
-                    return newcharColumn;
-                case Type decimalType when decimalType == typeof(decimal):
-                    throw new NotSupportedException();
-                case Type doubleType when doubleType == typeof(double):
-                    throw new NotSupportedException();
-                case Type floatType when floatType == typeof(float):
-                    throw new NotSupportedException();
-                case Type intType when intType == typeof(int):
-                    PrimitiveDataFrameColumn<int> intColumn = this as PrimitiveDataFrameColumn<int>;
-                    PrimitiveDataFrameColumn<int> newintColumn = inPlace ? intColumn : intColumn.Clone();
-                    newintColumn._columnContainer.LeftShift(value);
-                    return newintColumn;
-                case Type longType when longType == typeof(long):
-                    PrimitiveDataFrameColumn<long> longColumn = this as PrimitiveDataFrameColumn<long>;
-                    PrimitiveDataFrameColumn<long> newlongColumn = inPlace ? longColumn : longColumn.Clone();
-                    newlongColumn._columnContainer.LeftShift(value);
-                    return newlongColumn;
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                    PrimitiveDataFrameColumn<sbyte> sbyteColumn = this as PrimitiveDataFrameColumn<sbyte>;
-                    PrimitiveDataFrameColumn<sbyte> newsbyteColumn = inPlace ? sbyteColumn : sbyteColumn.Clone();
-                    newsbyteColumn._columnContainer.LeftShift(value);
-                    return newsbyteColumn;
-                case Type shortType when shortType == typeof(short):
-                    PrimitiveDataFrameColumn<short> shortColumn = this as PrimitiveDataFrameColumn<short>;
-                    PrimitiveDataFrameColumn<short> newshortColumn = inPlace ? shortColumn : shortColumn.Clone();
-                    newshortColumn._columnContainer.LeftShift(value);
-                    return newshortColumn;
-                case Type uintType when uintType == typeof(uint):
-                    PrimitiveDataFrameColumn<uint> uintColumn = this as PrimitiveDataFrameColumn<uint>;
-                    PrimitiveDataFrameColumn<uint> newuintColumn = inPlace ? uintColumn : uintColumn.Clone();
-                    newuintColumn._columnContainer.LeftShift(value);
-                    return newuintColumn;
-                case Type ulongType when ulongType == typeof(ulong):
-                    PrimitiveDataFrameColumn<ulong> ulongColumn = this as PrimitiveDataFrameColumn<ulong>;
-                    PrimitiveDataFrameColumn<ulong> newulongColumn = inPlace ? ulongColumn : ulongColumn.Clone();
-                    newulongColumn._columnContainer.LeftShift(value);
-                    return newulongColumn;
-                case Type ushortType when ushortType == typeof(ushort):
-                    PrimitiveDataFrameColumn<ushort> ushortColumn = this as PrimitiveDataFrameColumn<ushort>;
-                    PrimitiveDataFrameColumn<ushort> newushortColumn = inPlace ? ushortColumn : ushortColumn.Clone();
-                    newushortColumn._columnContainer.LeftShift(value);
-                    return newushortColumn;
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal DataFrameColumn RightShiftImplementation(int value, bool inPlace)
-        {
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                    PrimitiveDataFrameColumn<byte> byteColumn = this as PrimitiveDataFrameColumn<byte>;
-                    PrimitiveDataFrameColumn<byte> newbyteColumn = inPlace ? byteColumn : byteColumn.Clone();
-                    newbyteColumn._columnContainer.RightShift(value);
-                    return newbyteColumn;
-                case Type charType when charType == typeof(char):
-                    PrimitiveDataFrameColumn<char> charColumn = this as PrimitiveDataFrameColumn<char>;
-                    PrimitiveDataFrameColumn<char> newcharColumn = inPlace ? charColumn : charColumn.Clone();
-                    newcharColumn._columnContainer.RightShift(value);
-                    return newcharColumn;
-                case Type decimalType when decimalType == typeof(decimal):
-                    throw new NotSupportedException();
-                case Type doubleType when doubleType == typeof(double):
-                    throw new NotSupportedException();
-                case Type floatType when floatType == typeof(float):
-                    throw new NotSupportedException();
-                case Type intType when intType == typeof(int):
-                    PrimitiveDataFrameColumn<int> intColumn = this as PrimitiveDataFrameColumn<int>;
-                    PrimitiveDataFrameColumn<int> newintColumn = inPlace ? intColumn : intColumn.Clone();
-                    newintColumn._columnContainer.RightShift(value);
-                    return newintColumn;
-                case Type longType when longType == typeof(long):
-                    PrimitiveDataFrameColumn<long> longColumn = this as PrimitiveDataFrameColumn<long>;
-                    PrimitiveDataFrameColumn<long> newlongColumn = inPlace ? longColumn : longColumn.Clone();
-                    newlongColumn._columnContainer.RightShift(value);
-                    return newlongColumn;
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                    PrimitiveDataFrameColumn<sbyte> sbyteColumn = this as PrimitiveDataFrameColumn<sbyte>;
-                    PrimitiveDataFrameColumn<sbyte> newsbyteColumn = inPlace ? sbyteColumn : sbyteColumn.Clone();
-                    newsbyteColumn._columnContainer.RightShift(value);
-                    return newsbyteColumn;
-                case Type shortType when shortType == typeof(short):
-                    PrimitiveDataFrameColumn<short> shortColumn = this as PrimitiveDataFrameColumn<short>;
-                    PrimitiveDataFrameColumn<short> newshortColumn = inPlace ? shortColumn : shortColumn.Clone();
-                    newshortColumn._columnContainer.RightShift(value);
-                    return newshortColumn;
-                case Type uintType when uintType == typeof(uint):
-                    PrimitiveDataFrameColumn<uint> uintColumn = this as PrimitiveDataFrameColumn<uint>;
-                    PrimitiveDataFrameColumn<uint> newuintColumn = inPlace ? uintColumn : uintColumn.Clone();
-                    newuintColumn._columnContainer.RightShift(value);
-                    return newuintColumn;
-                case Type ulongType when ulongType == typeof(ulong):
-                    PrimitiveDataFrameColumn<ulong> ulongColumn = this as PrimitiveDataFrameColumn<ulong>;
-                    PrimitiveDataFrameColumn<ulong> newulongColumn = inPlace ? ulongColumn : ulongColumn.Clone();
-                    newulongColumn._columnContainer.RightShift(value);
-                    return newulongColumn;
-                case Type ushortType when ushortType == typeof(ushort):
-                    PrimitiveDataFrameColumn<ushort> ushortColumn = this as PrimitiveDataFrameColumn<ushort>;
-                    PrimitiveDataFrameColumn<ushort> newushortColumn = inPlace ? ushortColumn : ushortColumn.Clone();
-                    newushortColumn._columnContainer.RightShift(value);
-                    return newushortColumn;
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal PrimitiveDataFrameColumn<bool> ElementwiseEqualsImplementation<U>(PrimitiveDataFrameColumn<U> column)
-            where U : unmanaged
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    if (typeof(U) != typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<U>)._columnContainer.ElementwiseEquals(column._columnContainer));
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(column._columnContainer));
-                    }
-                    else
-                    {
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        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();
-                    }
-                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<U>)._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):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(column._columnContainer));
-                    }
-                    else
-                    {
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseEquals((column as PrimitiveDataFrameColumn<decimal>)._columnContainer));
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseEquals(column.CloneAsDoubleColumn()._columnContainer));
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal PrimitiveDataFrameColumn<bool> ElementwiseEqualsImplementation<U>(U value)
-        {
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    if (typeof(U) != typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<bool>)._columnContainer.ElementwiseEquals(Unsafe.As<U, bool>(ref value)));
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(Unsafe.As<U, T>(ref value)));
-                    }
-                    else
-                    {
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseEquals(DecimalConverter<U>.Instance.GetDecimal(value)));
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    if (typeof(U) != typeof(DateTime))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<DateTime>)._columnContainer.ElementwiseEquals(Unsafe.As<U, DateTime>(ref value)));
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(Unsafe.As<U, T>(ref value)));
-                    }
-                    else
-                    {
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseEquals(DecimalConverter<U>.Instance.GetDecimal(value)));
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseEquals(DoubleConverter<U>.Instance.GetDouble(value)));
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal PrimitiveDataFrameColumn<bool> ElementwiseNotEqualsImplementation<U>(PrimitiveDataFrameColumn<U> column)
-            where U : unmanaged
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    if (typeof(U) != typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<U>)._columnContainer.ElementwiseNotEquals(column._columnContainer));
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(column._columnContainer));
-                    }
-                    else
-                    {
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        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();
-                    }
-                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<U>)._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):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(column._columnContainer));
-                    }
-                    else
-                    {
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseNotEquals((column as PrimitiveDataFrameColumn<decimal>)._columnContainer));
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseNotEquals(column.CloneAsDoubleColumn()._columnContainer));
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal PrimitiveDataFrameColumn<bool> ElementwiseNotEqualsImplementation<U>(U value)
-        {
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    if (typeof(U) != typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<bool>)._columnContainer.ElementwiseNotEquals(Unsafe.As<U, bool>(ref value)));
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(Unsafe.As<U, T>(ref value)));
-                    }
-                    else
-                    {
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseNotEquals(DecimalConverter<U>.Instance.GetDecimal(value)));
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    if (typeof(U) != typeof(DateTime))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<DateTime>)._columnContainer.ElementwiseNotEquals(Unsafe.As<U, DateTime>(ref value)));
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(Unsafe.As<U, T>(ref value)));
-                    }
-                    else
-                    {
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseNotEquals(DecimalConverter<U>.Instance.GetDecimal(value)));
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseNotEquals(DoubleConverter<U>.Instance.GetDouble(value)));
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal PrimitiveDataFrameColumn<bool> ElementwiseGreaterThanOrEqualImplementation<U>(PrimitiveDataFrameColumn<U> column)
-            where U : unmanaged
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(column._columnContainer));
-                    }
-                    else
-                    {
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(column.CloneAsDecimalColumn()._columnContainer));
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(column._columnContainer));
-                    }
-                    else
-                    {
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual((column as PrimitiveDataFrameColumn<decimal>)._columnContainer));
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThanOrEqual(column.CloneAsDoubleColumn()._columnContainer));
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal PrimitiveDataFrameColumn<bool> ElementwiseGreaterThanOrEqualImplementation<U>(U value)
-        {
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(Unsafe.As<U, T>(ref value)));
-                    }
-                    else
-                    {
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(DecimalConverter<U>.Instance.GetDecimal(value)));
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(Unsafe.As<U, T>(ref value)));
-                    }
-                    else
-                    {
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(DecimalConverter<U>.Instance.GetDecimal(value)));
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThanOrEqual(DoubleConverter<U>.Instance.GetDouble(value)));
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal PrimitiveDataFrameColumn<bool> ElementwiseLessThanOrEqualImplementation<U>(PrimitiveDataFrameColumn<U> column)
-            where U : unmanaged
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(column._columnContainer));
-                    }
-                    else
-                    {
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual(column.CloneAsDecimalColumn()._columnContainer));
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(column._columnContainer));
-                    }
-                    else
-                    {
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual((column as PrimitiveDataFrameColumn<decimal>)._columnContainer));
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThanOrEqual(column.CloneAsDoubleColumn()._columnContainer));
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal PrimitiveDataFrameColumn<bool> ElementwiseLessThanOrEqualImplementation<U>(U value)
-        {
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(Unsafe.As<U, T>(ref value)));
-                    }
-                    else
-                    {
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual(DecimalConverter<U>.Instance.GetDecimal(value)));
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(Unsafe.As<U, T>(ref value)));
-                    }
-                    else
-                    {
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual(DecimalConverter<U>.Instance.GetDecimal(value)));
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThanOrEqual(DoubleConverter<U>.Instance.GetDouble(value)));
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal PrimitiveDataFrameColumn<bool> ElementwiseGreaterThanImplementation<U>(PrimitiveDataFrameColumn<U> column)
-            where U : unmanaged
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(column._columnContainer));
-                    }
-                    else
-                    {
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan(column.CloneAsDecimalColumn()._columnContainer));
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(column._columnContainer));
-                    }
-                    else
-                    {
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan((column as PrimitiveDataFrameColumn<decimal>)._columnContainer));
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThan(column.CloneAsDoubleColumn()._columnContainer));
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal PrimitiveDataFrameColumn<bool> ElementwiseGreaterThanImplementation<U>(U value)
-        {
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(Unsafe.As<U, T>(ref value)));
-                    }
-                    else
-                    {
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan(DecimalConverter<U>.Instance.GetDecimal(value)));
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(Unsafe.As<U, T>(ref value)));
-                    }
-                    else
-                    {
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan(DecimalConverter<U>.Instance.GetDecimal(value)));
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThan(DoubleConverter<U>.Instance.GetDouble(value)));
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal PrimitiveDataFrameColumn<bool> ElementwiseLessThanImplementation<U>(PrimitiveDataFrameColumn<U> column)
-            where U : unmanaged
-        {
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(column._columnContainer));
-                    }
-                    else
-                    {
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan(column.CloneAsDecimalColumn()._columnContainer));
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(column._columnContainer));
-                    }
-                    else
-                    {
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan((column as PrimitiveDataFrameColumn<decimal>)._columnContainer));
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThan(column.CloneAsDoubleColumn()._columnContainer));
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        internal PrimitiveDataFrameColumn<bool> ElementwiseLessThanImplementation<U>(U value)
-        {
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    throw new NotSupportedException();
-                case Type decimalType when decimalType == typeof(decimal):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(Unsafe.As<U, T>(ref value)));
-                    }
-                    else
-                    {
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan(DecimalConverter<U>.Instance.GetDecimal(value)));
-                    }
-                case Type DateTimeType when DateTimeType == typeof(DateTime):
-                    throw new NotSupportedException();
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(Unsafe.As<U, T>(ref value)));
-                    }
-                    else
-                    {
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan(DecimalConverter<U>.Instance.GetDecimal(value)));
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThan(DoubleConverter<U>.Instance.GetDouble(value)));
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
     }
 }
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt
index 356b70eb72..320fd2c455 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt
@@ -21,24 +21,32 @@ namespace Microsoft.Data.Analysis
         where T : unmanaged
     {
 <# foreach (MethodConfiguration method in methodConfiguration) { #>
-<# if (method.MethodType == MethodType.Binary || method.MethodType == MethodType.Comparison) {#>
 <# if (method.MethodType == MethodType.Binary) {#>
         /// <inheritdoc/>
         public override DataFrameColumn <#=method.MethodName#>(DataFrameColumn column, bool inPlace = false)
-<# } else { #>
+        {
+            switch (column)
+            {
+<# foreach (TypeConfiguration type in typeConfiguration) { #>
+                case PrimitiveDataFrameColumn<<#=type.TypeName#>> <#=type.TypeName#>Column:
+                    return HandleOperationImplementation(BinaryOperation.<#=method.MethodName#>, <#=type.TypeName#>Column, inPlace);
+<# } #>
+
+                default:
+                    throw new NotSupportedException();
+            }
+        }
+<# } #>
+<# if (method.MethodType == MethodType.Comparison) {#>
+
         /// <inheritdoc/>
         public override PrimitiveDataFrameColumn<bool> <#=method.MethodName#>(DataFrameColumn column)
-<# } #>
         {
             switch (column)
             {
 <# foreach (TypeConfiguration type in typeConfiguration) { #>
                 case PrimitiveDataFrameColumn<<#=type.TypeName#>> <#=type.TypeName#>Column:
-<# if (method.MethodType == MethodType.Binary) {#>
-                    return <#=method.MethodName#>Implementation(<#=type.TypeName#>Column, inPlace);
-<# } else { #>
-                    return <#=method.MethodName#>Implementation(<#=type.TypeName#>Column);
-<# } #>
+                    return HandleOperationImplementation(ComparisonOperation.<#=method.MethodName#>, <#=type.TypeName#>Column);
 <# } #>
 <# if (method.MethodName == "ElementwiseEquals") {#>
                 case null:
@@ -53,316 +61,57 @@ namespace Microsoft.Data.Analysis
                     throw new NotSupportedException();
             }
         }
-
 <# } #>
-<# if (method.MethodType == MethodType.BinaryScalar || method.MethodType == MethodType.ComparisonScalar) {#>
 <# if (method.MethodType == MethodType.BinaryScalar) {#>
 <# if (method.IsBitwise == true) { #>
+
         /// <inheritdoc/>
         public override PrimitiveDataFrameColumn<bool> <#=method.MethodName#>(bool value, bool inPlace = false)
+        {
+            return HandleBitwiseOperationImplementation(BinaryScalarOperation.<#=method.MethodName#>, value, inPlace);
+        }
 <# } else { #>
+
         /// <inheritdoc/>
         public override DataFrameColumn <#=method.MethodName#><U>(U value, bool inPlace = false)
-<# } #>
-<# } else {#>
-        /// <inheritdoc/>
-        public override PrimitiveDataFrameColumn<bool> <#=method.MethodName#><U>(U value)
-<# } #>
         {
-<# if (method.MethodType == MethodType.BinaryScalar) {#>
-<# if (method.IsBitwise == true) { #>
-            return <#=method.MethodName#>Implementation(value, inPlace);
-<# } else { #>
             DataFrameColumn column = value as DataFrameColumn;
             if (column != null)
             {
                 return <#=method.MethodName#>(column, inPlace);
             }
-            return <#=method.MethodName#>Implementation(value, inPlace);
+            return HandleOperationImplementation(BinaryScalarOperation.<#=method.MethodName#>, value, inPlace);
+        }
+
+        /// <inheritdoc/>
+        public override DataFrameColumn Reverse<#=method.MethodName#><U>(U value, bool inPlace = false)
+        {
+            return HandleReverseOperationImplementation(BinaryScalarOperation.<#=method.MethodName#>, value, inPlace);
+        }
 <# } #>
-<# } else {#>
+<# } #>
+<# if (method.MethodType == MethodType.ComparisonScalar) {#>
+
+        /// <inheritdoc/>
+        public override PrimitiveDataFrameColumn<bool> <#=method.MethodName#><U>(U value)
+        {
             DataFrameColumn column = value as DataFrameColumn;
             if (column != null)
             {
                 return <#=method.MethodName#>(column);
             }
-            return <#=method.MethodName#>Implementation(value);
-<# } #>
+            return HandleOperationImplementation(ComparisonScalarOperation.<#=method.MethodName#>, value);
         }
-
 <# } #>
 <# if (method.MethodType == MethodType.BinaryInt ) {#>
+
         /// <inheritdoc/>
         public override DataFrameColumn <#=method.MethodName#>(int value, bool inPlace = false)
         {
-            return <#=method.MethodName#>Implementation(value, inPlace);
+            return HandleOperationImplementation(BinaryIntOperation.<#=method.MethodName#>, value, inPlace);
         }
 <# } #>
 <# } #>
-<# foreach (MethodConfiguration method in methodConfiguration) { #>
 
-<# if (method.MethodType == MethodType.BinaryScalar || method.MethodType == MethodType.ComparisonScalar) {#>
-<# if (method.MethodType == MethodType.BinaryScalar) {#>
-<# if (method.IsBitwise == true) { #>
-        internal PrimitiveDataFrameColumn<bool> <#=method.MethodName#>Implementation<U>(U value, bool inPlace)
-<# } else { #>
-        internal DataFrameColumn <#=method.MethodName#>Implementation<U>(U value, bool inPlace)
-<# } #>
-<# } else {#>
-        internal PrimitiveDataFrameColumn<bool> <#=method.MethodName#>Implementation<U>(U value)
-<# } #>
-<# } #>
-<# if (method.MethodType == MethodType.Binary || method.MethodType == MethodType.Comparison) {#>
-<# if (method.MethodType == MethodType.Binary) {#>
-        internal DataFrameColumn <#=method.MethodName#>Implementation<U>(PrimitiveDataFrameColumn<U> column, bool inPlace)
-<# } else { #>
-        internal PrimitiveDataFrameColumn<bool> <#=method.MethodName#>Implementation<U>(PrimitiveDataFrameColumn<U> column)
-<# } #>
-            where U : unmanaged
-<# } #>
-<# if (method.MethodType == MethodType.BinaryInt ) {#>
-        internal DataFrameColumn <#=method.MethodName#>Implementation(int value, bool inPlace)
-<# } #>
-        {
-<# if (method.MethodType == MethodType.BinaryScalar || method.MethodType == MethodType.ComparisonScalar || method.MethodType == MethodType.BinaryInt) {#>
-<# } else { #>
-            if (column.Length != Length)
-            {
-                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
-            }
-<# } #>
-<# if (method.MethodType == MethodType.BinaryInt ) {#>
-            switch (typeof(T))
-            {
-<# foreach (TypeConfiguration type in typeConfiguration) { #>
-                case Type <#=type.TypeName#>Type when <#=type.TypeName#>Type == typeof(<#=type.TypeName#>):
-<# if (type.TypeName == "bool" || type.SupportsBitwise == false) { #>
-                    throw new NotSupportedException();
-<# } else { #>
-                    PrimitiveDataFrameColumn<<#=type.TypeName#>> <#=type.TypeName#>Column = this as PrimitiveDataFrameColumn<<#=type.TypeName#>>;
-                    PrimitiveDataFrameColumn<<#=type.TypeName#>> new<#=type.TypeName#>Column = inPlace ? <#=type.TypeName#>Column : <#=type.TypeName#>Column.Clone();
-                    new<#=type.TypeName#>Column._columnContainer.<#=method.MethodName#>(value);
-                    return new<#=type.TypeName#>Column;
-<# } #>
-<# } #>
-                default:
-                    throw new NotSupportedException();
-            }
-<# } else if (method.IsBitwise == true && method.IsNumeric == false) { #>
-            switch (typeof(T))
-            {
-                case Type boolType when boolType == typeof(bool):
-                    if (typeof(U) != typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-<# if (method.MethodType == MethodType.BinaryScalar) {#>
-                    PrimitiveDataFrameColumn<bool> typedColumn = this as PrimitiveDataFrameColumn<bool>;
-                    PrimitiveDataFrameColumn<bool> retColumn = <#=GenerateInPlaceStatement("typedColumn", "typedColumn.Clone()")#>;
-                    retColumn._columnContainer.<#=method.MethodName#>(Unsafe.As<U, bool>(ref value));
-                    return retColumn as PrimitiveDataFrameColumn<bool>;
-<# } else { #>
-                    PrimitiveDataFrameColumn<U> typedColumn = this as PrimitiveDataFrameColumn<U>;
-                    PrimitiveDataFrameColumn<U> retColumn = <#=GenerateInPlaceStatement("typedColumn", "typedColumn.Clone()")#>;
-                    retColumn._columnContainer.<#=method.MethodName#>(column._columnContainer);
-                    return retColumn;
-<# } #>
-<# foreach (TypeConfiguration type in typeConfiguration) { #>
-<# if (type.TypeName == "bool") { #>
-<# } else { #>
-                case Type <#=type.TypeName#>Type when <#=type.TypeName#>Type == typeof(<#=type.TypeName#>):
-<# } #>
-<# } #>
-                default:
-                    throw new NotSupportedException();
-            }
-<# } else { #>
-            switch (typeof(T))
-            {
-<# foreach (TypeConfiguration type in typeConfiguration) { #>
-<# if (type.TypeName == "bool" || type.TypeName == "DateTime") { #>
-                case Type <#=type.TypeName#>Type when <#=type.TypeName#>Type == typeof(<#=type.TypeName#>):
-<# if (method.IsNumeric == true) { #>
-                    throw new NotSupportedException();
-<# } else { #>
-                    if (typeof(U) != typeof(<#=type.TypeName#>))
-                    {
-                        throw new NotSupportedException();
-                    }
-<# if (method.MethodType == MethodType.ComparisonScalar) { #>
-                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<<#=type.TypeName#>>)._columnContainer.<#=method.MethodName#>(Unsafe.As<U, <#=type.TypeName#>>(ref value)));
-<# } else if (method.MethodType == MethodType.Comparison) { #>
-                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<U>)._columnContainer.<#=method.MethodName#>(column._columnContainer));
-<# } else if (method.MethodType == MethodType.BinaryScalar) {#>
-                    PrimitiveDataFrameColumn<U> column = this as PrimitiveDataFrameColumn<U>;
-                    PrimitiveDataFrameColumn<U> ret<#=type.TypeName#>Column = <#=GenerateInPlaceStatement("column", "column.Clone()")#>;
-                    ret<#=type.TypeName#>Column._columnContainer.<#=method.MethodName#>(value);
-<# } else { #>
-                    PrimitiveDataFrameColumn<U> column = this as PrimitiveDataFrameColumn<U>;
-                    PrimitiveDataFrameColumn<U> ret<#=type.TypeName#>Column = <#=GenerateInPlaceStatement("column", "column.Clone()")#>;
-                    ret<#=type.TypeName#>Column._columnContainer.<#=method.MethodName#>(column._columnContainer);
-<# } #>
-<# } #>
-<# } else if (type.TypeName == "decimal") { #>
-                case Type <#=type.TypeName#>Type when <#=type.TypeName#>Type == typeof(<#=type.TypeName#>):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-<# if (method.MethodType == MethodType.ComparisonScalar) { #>
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.<#=method.MethodName#>(Unsafe.As<U, T>(ref value)));
-<# } else if (method.MethodType == MethodType.Comparison){ #>
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.<#=method.MethodName#>(column._columnContainer));
-<# } else if (method.IsBitwise == true ) { #>
-                        throw new NotSupportedException();
-<# } else if (method.MethodType == MethodType.BinaryScalar ) { #>
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<T> newColumn = <#=GenerateInPlaceStatement("primitiveColumn", "primitiveColumn.Clone()")#>;
-                        newColumn._columnContainer.<#=method.MethodName#>(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-<# } else { #>
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<U> newColumn = <#=GenerateInPlaceStatement("primitiveColumn", "primitiveColumn.Clone()")#>;
-                        newColumn._columnContainer.<#=method.MethodName#>(column._columnContainer);
-                        return newColumn;
-<# } #>
-                    }
-                    else
-                    {
-<# if (method.MethodType == MethodType.BinaryScalar) { #>
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-<# } else if (method.MethodType == MethodType.Binary) { #>
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedColumnValueType, typeof(T)), nameof(column));
-                        }
-<# } #>
-<# if (method.MethodType == MethodType.ComparisonScalar) { #>
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.<#=method.MethodName#>(DecimalConverter<U>.Instance.GetDecimal(value)));
-<# } else if (method.MethodType == MethodType.Comparison){ #>
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        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) { #>
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.<#=method.MethodName#>(DecimalConverter<U>.Instance.GetDecimal(value));
-                        return decimalColumn;
-<# } else { #>
-                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.<#=method.MethodName#>(column.CloneAsDecimalColumn()._columnContainer);
-                        return decimalColumn;
-<# } #>
-                    }
-<# } else { #>
-<# } #>
-<# } #>
-                case Type byteType when byteType == typeof(byte):
-                case Type charType when charType == typeof(char):
-                case Type doubleType when doubleType == typeof(double):
-                case Type floatType when floatType == typeof(float):
-                case Type intType when intType == typeof(int):
-                case Type longType when longType == typeof(long):
-                case Type sbyteType when sbyteType == typeof(sbyte):
-                case Type shortType when shortType == typeof(short):
-                case Type uintType when uintType == typeof(uint):
-                case Type ulongType when ulongType == typeof(ulong):
-                case Type ushortType when ushortType == typeof(ushort):
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-<# if (method.MethodType == MethodType.ComparisonScalar) { #>
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.<#=method.MethodName#>(Unsafe.As<U, T>(ref value)));
-<# } else if (method.MethodType == MethodType.Comparison) { #>
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.<#=method.MethodName#>(column._columnContainer));
-<# } else if (method.IsBitwise == true ) { #>
-                        throw new NotSupportedException();
-<# } else if (method.MethodType == MethodType.BinaryScalar ) { #>
-                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<T> newColumn = <#=GenerateInPlaceStatement("primitiveColumn", "primitiveColumn.Clone()")#>;
-                        newColumn._columnContainer.<#=method.MethodName#>(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-<# } else { #>
-                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<U> newColumn = <#=GenerateInPlaceStatement("primitiveColumn", "primitiveColumn.Clone()")#>;
-                        newColumn._columnContainer.<#=method.MethodName#>(column._columnContainer);
-                        return newColumn;
-<# } #>
-                    }
-                    else
-                    {
-<# if (method.MethodType == MethodType.BinaryScalar) { #>
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-<# } else if (method.MethodType == MethodType.Binary) { #>
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedColumnValueType, typeof(T)), nameof(column));
-                        }
-<# } #>
-                        if (typeof(U) == typeof(decimal))
-                        {
-<# if (method.MethodType == MethodType.ComparisonScalar) { #>
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.<#=method.MethodName#>(DecimalConverter<U>.Instance.GetDecimal(value)));
-<# } else if (method.MethodType == MethodType.Comparison) { #>
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.<#=method.MethodName#>((column as PrimitiveDataFrameColumn<decimal>)._columnContainer));
-<# } else if (method.IsBitwise == true) { #>
-                            throw new NotSupportedException();
-<# } else if (method.MethodType == MethodType.BinaryScalar) { #>
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.<#=method.MethodName#>(DecimalConverter<U>.Instance.GetDecimal(value));
-                            return decimalColumn;
-<# } else { #>
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.<#=method.MethodName#>((column as PrimitiveDataFrameColumn<decimal>)._columnContainer);
-                            return decimalColumn;
-<# } #>
-                        }
-                        else
-                        {
-<# if (method.MethodType == MethodType.ComparisonScalar) { #>
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.<#=method.MethodName#>(DoubleConverter<U>.Instance.GetDouble(value)));
-<# } else if (method.MethodType == MethodType.Comparison) { #>
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            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 ) { #>
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.<#=method.MethodName#>(DoubleConverter<U>.Instance.GetDouble(value));
-                            return doubleColumn;
-<# } else { #>
-                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.<#=method.MethodName#>(column.CloneAsDoubleColumn()._columnContainer);
-                            return doubleColumn;
-<# } #>
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-<# } #>
-        }
-<# } #>
     }
 }
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.ReversedBinaryOperations.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.ReversedBinaryOperations.cs
deleted file mode 100644
index 3cc07217e3..0000000000
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.ReversedBinaryOperations.cs
+++ /dev/null
@@ -1,433 +0,0 @@
-
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-// Generated from PrimitiveDataFrameColumn.ReversedBinaryOperations.tt. Do not modify directly
-
-using System;
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-
-namespace Microsoft.Data.Analysis
-{
-    public partial class PrimitiveDataFrameColumn<T> : DataFrameColumn
-        where T : unmanaged
-    {
-
-        /// <inheritdoc/>
-        public override DataFrameColumn ReverseAdd<U>(U value, bool inPlace = false)
-        {
-            switch (this)
-            {
-                case PrimitiveDataFrameColumn<bool> boolColumn:
-                    throw new NotSupportedException();
-                case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? this : Clone();
-                        newColumn._columnContainer.ReverseAdd(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        PrimitiveDataFrameColumn<decimal> clonedDecimalColumn = CloneAsDecimalColumn();
-                        clonedDecimalColumn._columnContainer.ReverseAdd(DecimalConverter<U>.Instance.GetDecimal(value));
-                        return clonedDecimalColumn;
-                    }
-                case PrimitiveDataFrameColumn<byte> byteColumn:
-                case PrimitiveDataFrameColumn<char> charColumn:
-                case PrimitiveDataFrameColumn<double> doubleColumn:
-                case PrimitiveDataFrameColumn<float> floatColumn:
-                case PrimitiveDataFrameColumn<int> intColumn:
-                case PrimitiveDataFrameColumn<long> longColumn:
-                case PrimitiveDataFrameColumn<sbyte> sbyteColumn:
-                case PrimitiveDataFrameColumn<short> shortColumn:
-                case PrimitiveDataFrameColumn<uint> uintColumn:
-                case PrimitiveDataFrameColumn<ulong> ulongColumn:
-                case PrimitiveDataFrameColumn<ushort> ushortColumn:
-                case PrimitiveDataFrameColumn<DateTime> DateTimeColumn:
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? this : Clone();
-                        newColumn._columnContainer.ReverseAdd(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.ReverseAdd(DecimalConverter<U>.Instance.GetDecimal(value));
-                            return decimalColumn;
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> clonedDoubleColumn = CloneAsDoubleColumn();
-                            clonedDoubleColumn._columnContainer.ReverseAdd(DoubleConverter<U>.Instance.GetDouble(value));
-                            return clonedDoubleColumn;
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-        /// <inheritdoc/>
-        public override DataFrameColumn ReverseSubtract<U>(U value, bool inPlace = false)
-        {
-            switch (this)
-            {
-                case PrimitiveDataFrameColumn<bool> boolColumn:
-                    throw new NotSupportedException();
-                case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? this : Clone();
-                        newColumn._columnContainer.ReverseSubtract(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        PrimitiveDataFrameColumn<decimal> clonedDecimalColumn = CloneAsDecimalColumn();
-                        clonedDecimalColumn._columnContainer.ReverseSubtract(DecimalConverter<U>.Instance.GetDecimal(value));
-                        return clonedDecimalColumn;
-                    }
-                case PrimitiveDataFrameColumn<byte> byteColumn:
-                case PrimitiveDataFrameColumn<char> charColumn:
-                case PrimitiveDataFrameColumn<double> doubleColumn:
-                case PrimitiveDataFrameColumn<float> floatColumn:
-                case PrimitiveDataFrameColumn<int> intColumn:
-                case PrimitiveDataFrameColumn<long> longColumn:
-                case PrimitiveDataFrameColumn<sbyte> sbyteColumn:
-                case PrimitiveDataFrameColumn<short> shortColumn:
-                case PrimitiveDataFrameColumn<uint> uintColumn:
-                case PrimitiveDataFrameColumn<ulong> ulongColumn:
-                case PrimitiveDataFrameColumn<ushort> ushortColumn:
-                case PrimitiveDataFrameColumn<DateTime> DateTimeColumn:
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? this : Clone();
-                        newColumn._columnContainer.ReverseSubtract(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.ReverseSubtract(DecimalConverter<U>.Instance.GetDecimal(value));
-                            return decimalColumn;
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> clonedDoubleColumn = CloneAsDoubleColumn();
-                            clonedDoubleColumn._columnContainer.ReverseSubtract(DoubleConverter<U>.Instance.GetDouble(value));
-                            return clonedDoubleColumn;
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-        /// <inheritdoc/>
-        public override DataFrameColumn ReverseMultiply<U>(U value, bool inPlace = false)
-        {
-            switch (this)
-            {
-                case PrimitiveDataFrameColumn<bool> boolColumn:
-                    throw new NotSupportedException();
-                case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? this : Clone();
-                        newColumn._columnContainer.ReverseMultiply(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        PrimitiveDataFrameColumn<decimal> clonedDecimalColumn = CloneAsDecimalColumn();
-                        clonedDecimalColumn._columnContainer.ReverseMultiply(DecimalConverter<U>.Instance.GetDecimal(value));
-                        return clonedDecimalColumn;
-                    }
-                case PrimitiveDataFrameColumn<byte> byteColumn:
-                case PrimitiveDataFrameColumn<char> charColumn:
-                case PrimitiveDataFrameColumn<double> doubleColumn:
-                case PrimitiveDataFrameColumn<float> floatColumn:
-                case PrimitiveDataFrameColumn<int> intColumn:
-                case PrimitiveDataFrameColumn<long> longColumn:
-                case PrimitiveDataFrameColumn<sbyte> sbyteColumn:
-                case PrimitiveDataFrameColumn<short> shortColumn:
-                case PrimitiveDataFrameColumn<uint> uintColumn:
-                case PrimitiveDataFrameColumn<ulong> ulongColumn:
-                case PrimitiveDataFrameColumn<ushort> ushortColumn:
-                case PrimitiveDataFrameColumn<DateTime> DateTimeColumn:
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? this : Clone();
-                        newColumn._columnContainer.ReverseMultiply(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.ReverseMultiply(DecimalConverter<U>.Instance.GetDecimal(value));
-                            return decimalColumn;
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> clonedDoubleColumn = CloneAsDoubleColumn();
-                            clonedDoubleColumn._columnContainer.ReverseMultiply(DoubleConverter<U>.Instance.GetDouble(value));
-                            return clonedDoubleColumn;
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-        /// <inheritdoc/>
-        public override DataFrameColumn ReverseDivide<U>(U value, bool inPlace = false)
-        {
-            switch (this)
-            {
-                case PrimitiveDataFrameColumn<bool> boolColumn:
-                    throw new NotSupportedException();
-                case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? this : Clone();
-                        newColumn._columnContainer.ReverseDivide(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        PrimitiveDataFrameColumn<decimal> clonedDecimalColumn = CloneAsDecimalColumn();
-                        clonedDecimalColumn._columnContainer.ReverseDivide(DecimalConverter<U>.Instance.GetDecimal(value));
-                        return clonedDecimalColumn;
-                    }
-                case PrimitiveDataFrameColumn<byte> byteColumn:
-                case PrimitiveDataFrameColumn<char> charColumn:
-                case PrimitiveDataFrameColumn<double> doubleColumn:
-                case PrimitiveDataFrameColumn<float> floatColumn:
-                case PrimitiveDataFrameColumn<int> intColumn:
-                case PrimitiveDataFrameColumn<long> longColumn:
-                case PrimitiveDataFrameColumn<sbyte> sbyteColumn:
-                case PrimitiveDataFrameColumn<short> shortColumn:
-                case PrimitiveDataFrameColumn<uint> uintColumn:
-                case PrimitiveDataFrameColumn<ulong> ulongColumn:
-                case PrimitiveDataFrameColumn<ushort> ushortColumn:
-                case PrimitiveDataFrameColumn<DateTime> DateTimeColumn:
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? this : Clone();
-                        newColumn._columnContainer.ReverseDivide(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.ReverseDivide(DecimalConverter<U>.Instance.GetDecimal(value));
-                            return decimalColumn;
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> clonedDoubleColumn = CloneAsDoubleColumn();
-                            clonedDoubleColumn._columnContainer.ReverseDivide(DoubleConverter<U>.Instance.GetDouble(value));
-                            return clonedDoubleColumn;
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-        /// <inheritdoc/>
-        public override DataFrameColumn ReverseModulo<U>(U value, bool inPlace = false)
-        {
-            switch (this)
-            {
-                case PrimitiveDataFrameColumn<bool> boolColumn:
-                    throw new NotSupportedException();
-                case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? this : Clone();
-                        newColumn._columnContainer.ReverseModulo(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        PrimitiveDataFrameColumn<decimal> clonedDecimalColumn = CloneAsDecimalColumn();
-                        clonedDecimalColumn._columnContainer.ReverseModulo(DecimalConverter<U>.Instance.GetDecimal(value));
-                        return clonedDecimalColumn;
-                    }
-                case PrimitiveDataFrameColumn<byte> byteColumn:
-                case PrimitiveDataFrameColumn<char> charColumn:
-                case PrimitiveDataFrameColumn<double> doubleColumn:
-                case PrimitiveDataFrameColumn<float> floatColumn:
-                case PrimitiveDataFrameColumn<int> intColumn:
-                case PrimitiveDataFrameColumn<long> longColumn:
-                case PrimitiveDataFrameColumn<sbyte> sbyteColumn:
-                case PrimitiveDataFrameColumn<short> shortColumn:
-                case PrimitiveDataFrameColumn<uint> uintColumn:
-                case PrimitiveDataFrameColumn<ulong> ulongColumn:
-                case PrimitiveDataFrameColumn<ushort> ushortColumn:
-                case PrimitiveDataFrameColumn<DateTime> DateTimeColumn:
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? this : Clone();
-                        newColumn._columnContainer.ReverseModulo(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.ReverseModulo(DecimalConverter<U>.Instance.GetDecimal(value));
-                            return decimalColumn;
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> clonedDoubleColumn = CloneAsDoubleColumn();
-                            clonedDoubleColumn._columnContainer.ReverseModulo(DoubleConverter<U>.Instance.GetDouble(value));
-                            return clonedDoubleColumn;
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-        /// <inheritdoc/>
-        public override PrimitiveDataFrameColumn<bool> ReverseAnd(bool value, bool inPlace = false)
-        {
-            switch (this)
-            {
-                case PrimitiveDataFrameColumn<bool> boolColumn:
-                    PrimitiveDataFrameColumn<bool> retColumn = inPlace ? boolColumn : boolColumn.Clone();
-                    retColumn._columnContainer.ReverseAnd(value);
-                    return retColumn;
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-        /// <inheritdoc/>
-        public override PrimitiveDataFrameColumn<bool> ReverseOr(bool value, bool inPlace = false)
-        {
-            switch (this)
-            {
-                case PrimitiveDataFrameColumn<bool> boolColumn:
-                    PrimitiveDataFrameColumn<bool> retColumn = inPlace ? boolColumn : boolColumn.Clone();
-                    retColumn._columnContainer.ReverseOr(value);
-                    return retColumn;
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-        /// <inheritdoc/>
-        public override PrimitiveDataFrameColumn<bool> ReverseXor(bool value, bool inPlace = false)
-        {
-            switch (this)
-            {
-                case PrimitiveDataFrameColumn<bool> boolColumn:
-                    PrimitiveDataFrameColumn<bool> retColumn = inPlace ? boolColumn : boolColumn.Clone();
-                    retColumn._columnContainer.ReverseXor(value);
-                    return retColumn;
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-    }
-}
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.ReversedBinaryOperations.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.ReversedBinaryOperations.tt
deleted file mode 100644
index 6bb592486e..0000000000
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.ReversedBinaryOperations.tt
+++ /dev/null
@@ -1,116 +0,0 @@
-<#@ template debug="false" hostspecific="false" language="C#" #>
-<#@ assembly name="System.Core" #>
-<#@ import namespace="System.Linq" #>
-<#@ import namespace="System.Text" #>
-<#@ import namespace="System.Collections.Generic" #>
-<#@ output extension=".cs" #>
-<#@ include file="ColumnArithmeticTemplate.ttinclude" #>
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-// Generated from PrimitiveDataFrameColumn.ReversedBinaryOperations.tt. Do not modify directly
-
-using System;
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-
-namespace Microsoft.Data.Analysis
-{
-    public partial class PrimitiveDataFrameColumn<T> : DataFrameColumn
-        where T : unmanaged
-    {
-
-<# foreach (MethodConfiguration method in methodConfiguration) { #>
-<# if (method.MethodType == MethodType.BinaryScalar) {#>
-<# if (method.IsBitwise == true) { #>
-        /// <inheritdoc/>
-        public override PrimitiveDataFrameColumn<bool> Reverse<#=method.MethodName#>(bool value, bool inPlace = false)
-<# } else { #>
-        /// <inheritdoc/>
-        public override DataFrameColumn Reverse<#=method.MethodName#><U>(U value, bool inPlace = false)
-<# } #>
-        {
-<# if (method.IsBitwise == true) { #>
-            switch (this)
-            {
-                case PrimitiveDataFrameColumn<bool> boolColumn:
-                    PrimitiveDataFrameColumn<bool> retColumn = inPlace ? boolColumn : boolColumn.Clone();
-                    retColumn._columnContainer.Reverse<#=method.MethodName#>(value);
-                    return retColumn;
-                default:
-                    throw new NotSupportedException();
-            }
-<# } else { #>
-            switch (this)
-            {
-                case PrimitiveDataFrameColumn<bool> boolColumn:
-                    throw new NotSupportedException();
-                case PrimitiveDataFrameColumn<decimal> decimalColumn:
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? this : Clone();
-                        newColumn._columnContainer.Reverse<#=method.MethodName#>(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        PrimitiveDataFrameColumn<decimal> clonedDecimalColumn = CloneAsDecimalColumn();
-                        clonedDecimalColumn._columnContainer.Reverse<#=method.MethodName#>(DecimalConverter<U>.Instance.GetDecimal(value));
-                        return clonedDecimalColumn;
-                    }
-<# foreach (TypeConfiguration type in typeConfiguration) { #>
-<# if (type.TypeName == "bool") { #>
-<# } else if (type.TypeName == "decimal") { #>
-<# } else { #>
-                case PrimitiveDataFrameColumn<<#=type.TypeName#>> <#=type.TypeName#>Column:
-<# } #>
-<# } #>
-                    if (typeof(U) == typeof(bool))
-                    {
-                        throw new NotSupportedException();
-                    }
-                    if (typeof(U) == typeof(T))
-                    {
-                        // No conversions
-                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? this : Clone();
-                        newColumn._columnContainer.Reverse<#=method.MethodName#>(Unsafe.As<U, T>(ref value));
-                        return newColumn;
-                    }
-                    else
-                    {
-                        if (inPlace)
-                        {
-                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
-                        }
-                        if (typeof(U) == typeof(decimal))
-                        {
-                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.Reverse<#=method.MethodName#>(DecimalConverter<U>.Instance.GetDecimal(value));
-                            return decimalColumn;
-                        }
-                        else
-                        {
-                            PrimitiveDataFrameColumn<double> clonedDoubleColumn = CloneAsDoubleColumn();
-                            clonedDoubleColumn._columnContainer.Reverse<#=method.MethodName#>(DoubleConverter<U>.Instance.GetDouble(value));
-                            return clonedDoubleColumn;
-                        }
-                    }
-                default:
-                    throw new NotSupportedException();
-            }
-<# } #>
-        }
-<# } #>
-<# } #>
-    }
-}
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.Sort.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.Sort.cs
index a70bc1aecc..8896654bcf 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<T> comparer, out Int64Data
                 for (int i = 0; i < sortIndices.Length; i++)
                 {
                     int localSortIndex = sortIndices[i];
-                    if (BitmapHelper.IsValid(nullBitMapSpan, localSortIndex))
+                    if (BitUtility.IsValid(nullBitMapSpan, localSortIndex))
                     {
                         nonNullSortIndices.Add(sortIndices[i]);
                     }
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs
index 375f064bbb..6fe5270de4 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs
@@ -7,6 +7,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Apache.Arrow;
 using Apache.Arrow.Types;
@@ -586,7 +587,7 @@ public override Dictionary<TKey, ICollection<long>> GroupColumnValues<TKey>(out
                     for (int i = 0; i < readOnlySpan.Length; i++)
                     {
                         long currentLength = i + previousLength;
-                        if (BitmapHelper.IsValid(nullBitMapSpan, i))
+                        if (BitUtility.IsValid(nullBitMapSpan, i))
                         {
                             bool containsKey = multimap.TryGetValue(readOnlySpan[i], out ICollection<long> values);
                             if (containsKey)
@@ -890,5 +891,484 @@ public override PrimitiveDataFrameColumn<bool> ElementwiseIsNotNull()
 
             return ret;
         }
+
+        internal DataFrameColumn HandleOperationImplementation<U>(BinaryOperation operation, PrimitiveDataFrameColumn<U> column, bool inPlace)
+            where U : unmanaged
+        {
+            if (column.Length != Length)
+            {
+                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
+            }
+            switch (typeof(T))
+            {
+                case Type boolType when boolType == typeof(bool):
+                    throw new NotSupportedException();
+                case Type decimalType when decimalType == typeof(decimal):
+                    if (typeof(U) == typeof(bool))
+                    {
+                        throw new NotSupportedException();
+                    }
+                    if (typeof(U) == typeof(T))
+                    {
+                        // No conversions
+                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
+                        PrimitiveDataFrameColumn<U> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
+                        newColumn._columnContainer.HandleOperation(operation, column._columnContainer);
+                        return newColumn;
+                    }
+                    else
+                    {
+                        if (inPlace)
+                        {
+                            throw new ArgumentException(string.Format(Strings.MismatchedColumnValueType, typeof(T)), nameof(column));
+                        }
+                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
+                        decimalColumn._columnContainer.HandleOperation(operation, column.CloneAsDecimalColumn()._columnContainer);
+                        return decimalColumn;
+                    }
+                case Type DateTimeType when DateTimeType == typeof(DateTime):
+                    throw new NotSupportedException();
+                case Type byteType when byteType == typeof(byte):
+                case Type charType when charType == typeof(char):
+                case Type doubleType when doubleType == typeof(double):
+                case Type floatType when floatType == typeof(float):
+                case Type intType when intType == typeof(int):
+                case Type longType when longType == typeof(long):
+                case Type sbyteType when sbyteType == typeof(sbyte):
+                case Type shortType when shortType == typeof(short):
+                case Type uintType when uintType == typeof(uint):
+                case Type ulongType when ulongType == typeof(ulong):
+                case Type ushortType when ushortType == typeof(ushort):
+                    if (typeof(U) == typeof(bool))
+                    {
+                        throw new NotSupportedException();
+                    }
+                    if (typeof(U) == typeof(T))
+                    {
+                        // No conversions
+                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
+                        PrimitiveDataFrameColumn<U> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
+                        newColumn._columnContainer.HandleOperation(operation, column._columnContainer);
+                        return newColumn;
+                    }
+                    else
+                    {
+                        if (inPlace)
+                        {
+                            throw new ArgumentException(string.Format(Strings.MismatchedColumnValueType, typeof(T)), nameof(column));
+                        }
+                        if (typeof(U) == typeof(decimal))
+                        {
+                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
+                            decimalColumn._columnContainer.HandleOperation(operation, (column as PrimitiveDataFrameColumn<decimal>)._columnContainer);
+                            return decimalColumn;
+                        }
+                        else
+                        {
+                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
+                            doubleColumn._columnContainer.HandleOperation(operation, column.CloneAsDoubleColumn()._columnContainer);
+                            return doubleColumn;
+                        }
+                    }
+                default:
+                    throw new NotSupportedException();
+            }
+        }
+
+        internal DataFrameColumn HandleOperationImplementation<U>(BinaryScalarOperation operation, U value, bool inPlace)
+        {
+            switch (typeof(T))
+            {
+                case Type boolType when boolType == typeof(bool):
+                    throw new NotSupportedException();
+                case Type decimalType when decimalType == typeof(decimal):
+                    if (typeof(U) == typeof(bool))
+                    {
+                        throw new NotSupportedException();
+                    }
+                    if (typeof(U) == typeof(T))
+                    {
+                        // No conversions
+                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
+                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
+                        newColumn._columnContainer.HandleOperation(operation, Unsafe.As<U, T>(ref value));
+                        return newColumn;
+                    }
+                    else
+                    {
+                        if (inPlace)
+                        {
+                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
+                        }
+                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
+                        decimalColumn._columnContainer.HandleOperation(operation, DecimalConverter<U>.Instance.GetDecimal(value));
+                        return decimalColumn;
+                    }
+                case Type DateTimeType when DateTimeType == typeof(DateTime):
+                    throw new NotSupportedException();
+                case Type byteType when byteType == typeof(byte):
+                case Type charType when charType == typeof(char):
+                case Type doubleType when doubleType == typeof(double):
+                case Type floatType when floatType == typeof(float):
+                case Type intType when intType == typeof(int):
+                case Type longType when longType == typeof(long):
+                case Type sbyteType when sbyteType == typeof(sbyte):
+                case Type shortType when shortType == typeof(short):
+                case Type uintType when uintType == typeof(uint):
+                case Type ulongType when ulongType == typeof(ulong):
+                case Type ushortType when ushortType == typeof(ushort):
+                    if (typeof(U) == typeof(bool))
+                    {
+                        throw new NotSupportedException();
+                    }
+                    if (typeof(U) == typeof(T))
+                    {
+                        // No conversions
+                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
+                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? primitiveColumn : primitiveColumn.Clone();
+                        newColumn._columnContainer.HandleOperation(operation, Unsafe.As<U, T>(ref value));
+                        return newColumn;
+                    }
+                    else
+                    {
+                        if (inPlace)
+                        {
+                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
+                        }
+                        if (typeof(U) == typeof(decimal))
+                        {
+                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
+                            decimalColumn._columnContainer.HandleOperation(operation, DecimalConverter<U>.Instance.GetDecimal(value));
+                            return decimalColumn;
+                        }
+                        else
+                        {
+                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
+                            doubleColumn._columnContainer.HandleOperation(operation, DoubleConverter<U>.Instance.GetDouble(value));
+                            return doubleColumn;
+                        }
+                    }
+                default:
+                    throw new NotSupportedException();
+            }
+        }
+
+        internal DataFrameColumn HandleReverseOperationImplementation<U>(BinaryScalarOperation operation, U value, bool inPlace = false)
+        {
+            switch (typeof(T))
+            {
+                case Type boolType when boolType == typeof(bool):
+                    throw new NotSupportedException();
+                case Type decimalType when decimalType == typeof(decimal):
+                    if (typeof(U) == typeof(bool))
+                    {
+                        throw new NotSupportedException();
+                    }
+                    if (typeof(U) == typeof(T))
+                    {
+                        // No conversions
+                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? this : Clone();
+                        newColumn._columnContainer.HandleReverseOperation(operation, Unsafe.As<U, T>(ref value));
+                        return newColumn;
+                    }
+                    else
+                    {
+                        if (inPlace)
+                        {
+                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
+                        }
+                        PrimitiveDataFrameColumn<decimal> clonedDecimalColumn = CloneAsDecimalColumn();
+                        clonedDecimalColumn._columnContainer.HandleReverseOperation(operation, DecimalConverter<U>.Instance.GetDecimal(value));
+                        return clonedDecimalColumn;
+                    }
+                case Type DateTimeType when DateTimeType == typeof(DateTime):
+                    throw new NotSupportedException();
+                case Type byteType when byteType == typeof(byte):
+                case Type charType when charType == typeof(char):
+                case Type doubleType when doubleType == typeof(double):
+                case Type floatType when floatType == typeof(float):
+                case Type intType when intType == typeof(int):
+                case Type longType when longType == typeof(long):
+                case Type sbyteType when sbyteType == typeof(sbyte):
+                case Type shortType when shortType == typeof(short):
+                case Type uintType when uintType == typeof(uint):
+                case Type ulongType when ulongType == typeof(ulong):
+                case Type ushortType when ushortType == typeof(ushort):
+                    if (typeof(U) == typeof(bool))
+                    {
+                        throw new NotSupportedException();
+                    }
+                    if (typeof(U) == typeof(T))
+                    {
+                        // No conversions
+                        PrimitiveDataFrameColumn<T> newColumn = inPlace ? this : Clone();
+                        newColumn._columnContainer.HandleReverseOperation(operation, Unsafe.As<U, T>(ref value));
+                        return newColumn;
+                    }
+                    else
+                    {
+                        if (inPlace)
+                        {
+                            throw new ArgumentException(string.Format(Strings.MismatchedValueType, typeof(T)), nameof(value));
+                        }
+                        if (typeof(U) == typeof(decimal))
+                        {
+                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
+                            decimalColumn._columnContainer.HandleReverseOperation(operation, DecimalConverter<U>.Instance.GetDecimal(value));
+                            return decimalColumn;
+                        }
+                        else
+                        {
+                            PrimitiveDataFrameColumn<double> clonedDoubleColumn = CloneAsDoubleColumn();
+                            clonedDoubleColumn._columnContainer.HandleReverseOperation(operation, DoubleConverter<U>.Instance.GetDouble(value));
+                            return clonedDoubleColumn;
+                        }
+                    }
+                default:
+                    throw new NotSupportedException();
+            }
+        }
+
+        internal PrimitiveDataFrameColumn<bool> HandleBitwiseOperationImplementation<U>(BinaryScalarOperation operation, U value, bool inPlace)
+        {
+            switch (typeof(T))
+            {
+                case Type boolType when boolType == typeof(bool):
+                    if (typeof(U) != typeof(bool))
+                    {
+                        throw new NotSupportedException();
+                    }
+                    PrimitiveDataFrameColumn<bool> typedColumn = this as PrimitiveDataFrameColumn<bool>;
+                    PrimitiveDataFrameColumn<bool> retColumn = inPlace ? typedColumn : typedColumn.Clone();
+                    retColumn._columnContainer.HandleOperation(operation, Unsafe.As<U, bool>(ref value));
+                    return retColumn;
+                case Type byteType when byteType == typeof(byte):
+                case Type charType when charType == typeof(char):
+                case Type decimalType when decimalType == typeof(decimal):
+                case Type doubleType when doubleType == typeof(double):
+                case Type floatType when floatType == typeof(float):
+                case Type intType when intType == typeof(int):
+                case Type longType when longType == typeof(long):
+                case Type sbyteType when sbyteType == typeof(sbyte):
+                case Type shortType when shortType == typeof(short):
+                case Type uintType when uintType == typeof(uint):
+                case Type ulongType when ulongType == typeof(ulong):
+                case Type ushortType when ushortType == typeof(ushort):
+                case Type DateTimeType when DateTimeType == typeof(DateTime):
+                default:
+                    throw new NotSupportedException();
+            }
+        }
+
+        internal DataFrameColumn HandleOperationImplementation(BinaryIntOperation operation, int value, bool inPlace)
+        {
+            switch (typeof(T))
+            {
+                case Type boolType when boolType == typeof(bool):
+                    throw new NotSupportedException();
+                case Type byteType when byteType == typeof(byte):
+                    PrimitiveDataFrameColumn<byte> byteColumn = this as PrimitiveDataFrameColumn<byte>;
+                    PrimitiveDataFrameColumn<byte> newbyteColumn = inPlace ? byteColumn : byteColumn.Clone();
+                    newbyteColumn._columnContainer.HandleOperation(operation, value);
+                    return newbyteColumn;
+                case Type charType when charType == typeof(char):
+                    PrimitiveDataFrameColumn<char> charColumn = this as PrimitiveDataFrameColumn<char>;
+                    PrimitiveDataFrameColumn<char> newcharColumn = inPlace ? charColumn : charColumn.Clone();
+                    newcharColumn._columnContainer.HandleOperation(operation, value);
+                    return newcharColumn;
+                case Type decimalType when decimalType == typeof(decimal):
+                    throw new NotSupportedException();
+                case Type doubleType when doubleType == typeof(double):
+                    throw new NotSupportedException();
+                case Type floatType when floatType == typeof(float):
+                    throw new NotSupportedException();
+                case Type intType when intType == typeof(int):
+                    PrimitiveDataFrameColumn<int> intColumn = this as PrimitiveDataFrameColumn<int>;
+                    PrimitiveDataFrameColumn<int> newintColumn = inPlace ? intColumn : intColumn.Clone();
+                    newintColumn._columnContainer.HandleOperation(operation, value);
+                    return newintColumn;
+                case Type longType when longType == typeof(long):
+                    PrimitiveDataFrameColumn<long> longColumn = this as PrimitiveDataFrameColumn<long>;
+                    PrimitiveDataFrameColumn<long> newlongColumn = inPlace ? longColumn : longColumn.Clone();
+                    newlongColumn._columnContainer.HandleOperation(operation, value);
+                    return newlongColumn;
+                case Type sbyteType when sbyteType == typeof(sbyte):
+                    PrimitiveDataFrameColumn<sbyte> sbyteColumn = this as PrimitiveDataFrameColumn<sbyte>;
+                    PrimitiveDataFrameColumn<sbyte> newsbyteColumn = inPlace ? sbyteColumn : sbyteColumn.Clone();
+                    newsbyteColumn._columnContainer.HandleOperation(operation, value);
+                    return newsbyteColumn;
+                case Type shortType when shortType == typeof(short):
+                    PrimitiveDataFrameColumn<short> shortColumn = this as PrimitiveDataFrameColumn<short>;
+                    PrimitiveDataFrameColumn<short> newshortColumn = inPlace ? shortColumn : shortColumn.Clone();
+                    newshortColumn._columnContainer.HandleOperation(operation, value);
+                    return newshortColumn;
+                case Type uintType when uintType == typeof(uint):
+                    PrimitiveDataFrameColumn<uint> uintColumn = this as PrimitiveDataFrameColumn<uint>;
+                    PrimitiveDataFrameColumn<uint> newuintColumn = inPlace ? uintColumn : uintColumn.Clone();
+                    newuintColumn._columnContainer.HandleOperation(operation, value);
+                    return newuintColumn;
+                case Type ulongType when ulongType == typeof(ulong):
+                    PrimitiveDataFrameColumn<ulong> ulongColumn = this as PrimitiveDataFrameColumn<ulong>;
+                    PrimitiveDataFrameColumn<ulong> newulongColumn = inPlace ? ulongColumn : ulongColumn.Clone();
+                    newulongColumn._columnContainer.HandleOperation(operation, value);
+                    return newulongColumn;
+                case Type ushortType when ushortType == typeof(ushort):
+                    PrimitiveDataFrameColumn<ushort> ushortColumn = this as PrimitiveDataFrameColumn<ushort>;
+                    PrimitiveDataFrameColumn<ushort> newushortColumn = inPlace ? ushortColumn : ushortColumn.Clone();
+                    newushortColumn._columnContainer.HandleOperation(operation, value);
+                    return newushortColumn;
+                case Type DateTimeType when DateTimeType == typeof(DateTime):
+                    throw new NotSupportedException();
+                default:
+                    throw new NotSupportedException();
+            }
+        }
+
+        internal PrimitiveDataFrameColumn<bool> HandleOperationImplementation<U>(ComparisonOperation operation, PrimitiveDataFrameColumn<U> column)
+            where U : unmanaged
+        {
+            if (column.Length != Length)
+            {
+                throw new ArgumentException(Strings.MismatchedColumnLengths, nameof(column));
+            }
+            switch (typeof(T))
+            {
+                case Type boolType when boolType == typeof(bool):
+                    if (typeof(U) != typeof(bool))
+                    {
+                        throw new NotSupportedException();
+                    }
+                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<U>)._columnContainer.HandleOperation(operation, column._columnContainer));
+                case Type decimalType when decimalType == typeof(decimal):
+                    if (typeof(U) == typeof(bool))
+                    {
+                        throw new NotSupportedException();
+                    }
+                    if (typeof(U) == typeof(T))
+                    {
+                        // No conversions
+                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.HandleOperation(operation, column._columnContainer));
+                    }
+                    else
+                    {
+                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
+                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.HandleOperation(operation, column.CloneAsDecimalColumn()._columnContainer));
+                    }
+                case Type DateTimeType when DateTimeType == typeof(DateTime):
+                    if (typeof(U) != typeof(DateTime))
+                    {
+                        throw new NotSupportedException();
+                    }
+                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<U>)._columnContainer.HandleOperation(operation, column._columnContainer));
+                case Type byteType when byteType == typeof(byte):
+                case Type charType when charType == typeof(char):
+                case Type doubleType when doubleType == typeof(double):
+                case Type floatType when floatType == typeof(float):
+                case Type intType when intType == typeof(int):
+                case Type longType when longType == typeof(long):
+                case Type sbyteType when sbyteType == typeof(sbyte):
+                case Type shortType when shortType == typeof(short):
+                case Type uintType when uintType == typeof(uint):
+                case Type ulongType when ulongType == typeof(ulong):
+                case Type ushortType when ushortType == typeof(ushort):
+                    if (typeof(U) == typeof(bool))
+                    {
+                        throw new NotSupportedException();
+                    }
+                    if (typeof(U) == typeof(T))
+                    {
+                        // No conversions
+                        PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.HandleOperation(operation, column._columnContainer));
+                    }
+                    else
+                    {
+                        if (typeof(U) == typeof(decimal))
+                        {
+                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
+                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.HandleOperation(operation, (column as PrimitiveDataFrameColumn<decimal>)._columnContainer));
+                        }
+                        else
+                        {
+                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
+                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.HandleOperation(operation, column.CloneAsDoubleColumn()._columnContainer));
+                        }
+                    }
+                default:
+                    throw new NotSupportedException();
+            }
+        }
+
+        internal PrimitiveDataFrameColumn<bool> HandleOperationImplementation<U>(ComparisonScalarOperation operation, U value)
+        {
+            switch (typeof(T))
+            {
+                case Type boolType when boolType == typeof(bool):
+                    if (typeof(U) != typeof(bool))
+                    {
+                        throw new NotSupportedException();
+                    }
+                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<bool>)._columnContainer.HandleOperation(operation, Unsafe.As<U, bool>(ref value)));
+                case Type decimalType when decimalType == typeof(decimal):
+                    if (typeof(U) == typeof(bool))
+                    {
+                        throw new NotSupportedException();
+                    }
+                    if (typeof(U) == typeof(T))
+                    {
+                        // No conversions
+                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.HandleOperation(operation, Unsafe.As<U, T>(ref value)));
+                    }
+                    else
+                    {
+                        PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
+                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.HandleOperation(operation, DecimalConverter<U>.Instance.GetDecimal(value)));
+                    }
+                case Type DateTimeType when DateTimeType == typeof(DateTime):
+                    if (typeof(U) != typeof(DateTime))
+                    {
+                        throw new NotSupportedException();
+                    }
+                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<DateTime>)._columnContainer.HandleOperation(operation, Unsafe.As<U, DateTime>(ref value)));
+                case Type byteType when byteType == typeof(byte):
+                case Type charType when charType == typeof(char):
+                case Type doubleType when doubleType == typeof(double):
+                case Type floatType when floatType == typeof(float):
+                case Type intType when intType == typeof(int):
+                case Type longType when longType == typeof(long):
+                case Type sbyteType when sbyteType == typeof(sbyte):
+                case Type shortType when shortType == typeof(short):
+                case Type uintType when uintType == typeof(uint):
+                case Type ulongType when ulongType == typeof(ulong):
+                case Type ushortType when ushortType == typeof(ushort):
+                    if (typeof(U) == typeof(bool))
+                    {
+                        throw new NotSupportedException();
+                    }
+                    if (typeof(U) == typeof(T))
+                    {
+                        // No conversions
+                        PrimitiveDataFrameColumn<T> primitiveColumn = this;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.HandleOperation(operation, Unsafe.As<U, T>(ref value)));
+                    }
+                    else
+                    {
+                        if (typeof(U) == typeof(decimal))
+                        {
+                            PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
+                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.HandleOperation(operation, DecimalConverter<U>.Instance.GetDecimal(value)));
+                        }
+                        else
+                        {
+                            PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
+                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.HandleOperation(operation, DoubleConverter<U>.Instance.GetDouble(value)));
+                        }
+                    }
+                default:
+                    throw new NotSupportedException();
+            }
+        }
     }
 }
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs
index d315e34163..b43addb421 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs
@@ -1,5 +1,4 @@
 
-
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
@@ -10,92 +9,191 @@
 
 namespace Microsoft.Data.Analysis
 {
-    internal interface IPrimitiveDataFrameColumnArithmetic<T>
-        where T : unmanaged
-    {
-        void Add(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        void Add(PrimitiveColumnContainer<T> column, T scalar);
-        void Add(T scalar, PrimitiveColumnContainer<T> column);
-        void Subtract(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        void Subtract(PrimitiveColumnContainer<T> column, T scalar);
-        void Subtract(T scalar, PrimitiveColumnContainer<T> column);
-        void Multiply(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        void Multiply(PrimitiveColumnContainer<T> column, T scalar);
-        void Multiply(T scalar, PrimitiveColumnContainer<T> column);
-        void Divide(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        void Divide(PrimitiveColumnContainer<T> column, T scalar);
-        void Divide(T scalar, PrimitiveColumnContainer<T> column);
-        void Modulo(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        void Modulo(PrimitiveColumnContainer<T> column, T scalar);
-        void Modulo(T scalar, PrimitiveColumnContainer<T> column);
-        void And(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        void And(PrimitiveColumnContainer<T> column, T scalar);
-        void And(T scalar, PrimitiveColumnContainer<T> column);
-        void Or(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        void Or(PrimitiveColumnContainer<T> column, T scalar);
-        void Or(T scalar, PrimitiveColumnContainer<T> column);
-        void Xor(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        void Xor(PrimitiveColumnContainer<T> column, T scalar);
-        void Xor(T scalar, PrimitiveColumnContainer<T> column);
-        void LeftShift(PrimitiveColumnContainer<T> column, int value);
-        void RightShift(PrimitiveColumnContainer<T> column, int value);
-        PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<T> column, T scalar);
-        PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<T> column, T scalar);
-        PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<T> column, T scalar);
-        PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<T> column, T scalar);
-        PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<T> column, T scalar);
-        PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<T> column, T scalar);
-    }
-
     internal class PrimitiveDataFrameColumnArithmetic<T> : IPrimitiveDataFrameColumnArithmetic<T>
         where T : unmanaged
     {
         public static IPrimitiveDataFrameColumnArithmetic<T> Instance { get; } = PrimitiveDataFrameColumnArithmetic.GetArithmetic<T>();
 
-        public virtual void Add(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right) => throw new NotSupportedException();
-        public virtual void Add(PrimitiveColumnContainer<T> column, T scalar) => throw new NotSupportedException();
-        public virtual void Add(T scalar, PrimitiveColumnContainer<T> column) => throw new NotSupportedException();
-        public virtual void Subtract(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right) => throw new NotSupportedException();
-        public virtual void Subtract(PrimitiveColumnContainer<T> column, T scalar) => throw new NotSupportedException();
-        public virtual void Subtract(T scalar, PrimitiveColumnContainer<T> column) => throw new NotSupportedException();
-        public virtual void Multiply(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right) => throw new NotSupportedException();
-        public virtual void Multiply(PrimitiveColumnContainer<T> column, T scalar) => throw new NotSupportedException();
-        public virtual void Multiply(T scalar, PrimitiveColumnContainer<T> column) => throw new NotSupportedException();
-        public virtual void Divide(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right) => throw new NotSupportedException();
-        public virtual void Divide(PrimitiveColumnContainer<T> column, T scalar) => throw new NotSupportedException();
-        public virtual void Divide(T scalar, PrimitiveColumnContainer<T> column) => throw new NotSupportedException();
-        public virtual void Modulo(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right) => throw new NotSupportedException();
-        public virtual void Modulo(PrimitiveColumnContainer<T> column, T scalar) => throw new NotSupportedException();
-        public virtual void Modulo(T scalar, PrimitiveColumnContainer<T> column) => throw new NotSupportedException();
-        public virtual void And(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right) => throw new NotSupportedException();
-        public virtual void And(PrimitiveColumnContainer<T> column, T scalar) => throw new NotSupportedException();
-        public virtual void And(T scalar, PrimitiveColumnContainer<T> column) => throw new NotSupportedException();
-        public virtual void Or(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right) => throw new NotSupportedException();
-        public virtual void Or(PrimitiveColumnContainer<T> column, T scalar) => throw new NotSupportedException();
-        public virtual void Or(T scalar, PrimitiveColumnContainer<T> column) => throw new NotSupportedException();
-        public virtual void Xor(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right) => throw new NotSupportedException();
-        public virtual void Xor(PrimitiveColumnContainer<T> column, T scalar) => throw new NotSupportedException();
-        public virtual void Xor(T scalar, PrimitiveColumnContainer<T> column) => throw new NotSupportedException();
-        public virtual void LeftShift(PrimitiveColumnContainer<T> column, int value) => throw new NotSupportedException();
-        public virtual void RightShift(PrimitiveColumnContainer<T> column, int value) => throw new NotSupportedException();
-        public virtual PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right) => throw new NotSupportedException();
-        public virtual PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<T> column, T scalar) => throw new NotSupportedException();
-        public virtual PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right) => throw new NotSupportedException();
-        public virtual PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<T> column, T scalar) => throw new NotSupportedException();
-        public virtual PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right) => throw new NotSupportedException();
-        public virtual PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<T> column, T scalar) => throw new NotSupportedException();
-        public virtual PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right) => throw new NotSupportedException();
-        public virtual PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<T> column, T scalar) => throw new NotSupportedException();
-        public virtual PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right) => throw new NotSupportedException();
-        public virtual PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<T> column, T scalar) => throw new NotSupportedException();
-        public virtual PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right) => throw new NotSupportedException();
-        public virtual PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<T> column, T scalar) => throw new NotSupportedException();
+        public void HandleOperation(BinaryOperation operation, Span<T> left, Span<byte> leftValidity, ReadOnlySpan<T> right, ReadOnlySpan<byte> rightValidity)
+        {
+            if (operation == BinaryOperation.Divide)
+            {
+                Divide(left, leftValidity, right, rightValidity);
+                return;
+            }
+            else if (operation == BinaryOperation.Add)
+                Add(left, right);
+            else if (operation == BinaryOperation.Subtract)
+                Subtract(left, right);
+            else if (operation == BinaryOperation.Multiply)
+                Multiply(left, right);
+            else if (operation == BinaryOperation.Modulo)
+                Modulo(left, right);
+            else if (operation == BinaryOperation.And)
+                And(left, right);
+            else if (operation == BinaryOperation.Or)
+                Or(left, right);
+            else if (operation == BinaryOperation.Xor)
+                Xor(left, right);
+
+            BitUtility.ElementwiseAnd(leftValidity, rightValidity, leftValidity);
+        }
+
+        public void HandleOperation(BinaryScalarOperation operation, Span<T> left, T right)
+        {
+            switch (operation)
+            {
+                case BinaryScalarOperation.Add:
+                    Add(left, right);
+                    break;
+                case BinaryScalarOperation.Subtract:
+                    Subtract(left, right);
+                    break;
+                case BinaryScalarOperation.Multiply:
+                    Multiply(left, right);
+                    break;
+                case BinaryScalarOperation.Divide:
+                    Divide(left, right);
+                    break;
+                case BinaryScalarOperation.Modulo:
+                    Modulo(left, right);
+                    break;
+                case BinaryScalarOperation.And:
+                    And(left, right);
+                    break;
+                case BinaryScalarOperation.Or:
+                    Or(left, right);
+                    break;
+                case BinaryScalarOperation.Xor:
+                    Xor(left, right);
+                    break;
+            }
+        }
+
+        public void HandleOperation(BinaryScalarOperation operation, T left, Span<T> right, ReadOnlySpan<byte> rightValidity)
+        {
+            if (operation == BinaryScalarOperation.Divide)
+            {
+                Divide(left, right, rightValidity);
+                return;
+            }
+            else if (operation == BinaryScalarOperation.Add)
+                Add(left, right);
+            else if (operation == BinaryScalarOperation.Subtract)
+                Subtract(left, right);
+            else if (operation == BinaryScalarOperation.Multiply)
+                Multiply(left, right);
+            else if (operation == BinaryScalarOperation.Modulo)
+                Modulo(left, right);
+            else if (operation == BinaryScalarOperation.And)
+                And(left, right);
+            else if (operation == BinaryScalarOperation.Or)
+                Or(left, right);
+            else if (operation == BinaryScalarOperation.Xor)
+                Xor(left, right);
+        }
+
+        public void HandleOperation(BinaryIntOperation operation, Span<T> left, int right)
+        {
+            switch (operation)
+            {
+                case BinaryIntOperation.LeftShift:
+                    LeftShift(left, right);
+                    break;
+                case BinaryIntOperation.RightShift:
+                    RightShift(left, right);
+                    break;
+            }
+        }
+
+        public void HandleOperation(ComparisonOperation operation, ReadOnlySpan<T> left, ReadOnlySpan<T> right, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            switch (operation)
+            {
+                case ComparisonOperation.ElementwiseEquals:
+                    ElementwiseEquals(left, right, result, offset);
+                    break;
+                case ComparisonOperation.ElementwiseNotEquals:
+                    ElementwiseNotEquals(left, right, result, offset);
+                    break;
+                case ComparisonOperation.ElementwiseGreaterThanOrEqual:
+                    ElementwiseGreaterThanOrEqual(left, right, result, offset);
+                    break;
+                case ComparisonOperation.ElementwiseLessThanOrEqual:
+                    ElementwiseLessThanOrEqual(left, right, result, offset);
+                    break;
+                case ComparisonOperation.ElementwiseGreaterThan:
+                    ElementwiseGreaterThan(left, right, result, offset);
+                    break;
+                case ComparisonOperation.ElementwiseLessThan:
+                    ElementwiseLessThan(left, right, result, offset);
+                    break;
+            }
+        }
+
+        public void HandleOperation(ComparisonScalarOperation operation, ReadOnlySpan<T> left, T right, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            switch (operation)
+            {
+                case ComparisonScalarOperation.ElementwiseEquals:
+                    ElementwiseEquals(left, right, result, offset);
+                    break;
+                case ComparisonScalarOperation.ElementwiseNotEquals:
+                    ElementwiseNotEquals(left, right, result, offset);
+                    break;
+                case ComparisonScalarOperation.ElementwiseGreaterThanOrEqual:
+                    ElementwiseGreaterThanOrEqual(left, right, result, offset);
+                    break;
+                case ComparisonScalarOperation.ElementwiseLessThanOrEqual:
+                    ElementwiseLessThanOrEqual(left, right, result, offset);
+                    break;
+                case ComparisonScalarOperation.ElementwiseGreaterThan:
+                    ElementwiseGreaterThan(left, right, result, offset);
+                    break;
+                case ComparisonScalarOperation.ElementwiseLessThan:
+                    ElementwiseLessThan(left, right, result, offset);
+                    break;
+            }
+        }
+
+        protected virtual void Add(Span<T> left, ReadOnlySpan<T> right) => throw new NotSupportedException();
+        protected virtual void Add(Span<T> left, T scalar) => throw new NotSupportedException();
+        protected virtual void Add(T left, Span<T> right) => throw new NotSupportedException();
+        protected virtual void Subtract(Span<T> left, ReadOnlySpan<T> right) => throw new NotSupportedException();
+        protected virtual void Subtract(Span<T> left, T scalar) => throw new NotSupportedException();
+        protected virtual void Subtract(T left, Span<T> right) => throw new NotSupportedException();
+        protected virtual void Multiply(Span<T> left, ReadOnlySpan<T> right) => throw new NotSupportedException();
+        protected virtual void Multiply(Span<T> left, T scalar) => throw new NotSupportedException();
+        protected virtual void Multiply(T left, Span<T> right) => throw new NotSupportedException();
+        protected virtual void Divide(Span<T> left, Span<byte> leftValidity, ReadOnlySpan<T> right, ReadOnlySpan<byte> rightValidity) => throw new NotSupportedException();
+        protected virtual void Divide(Span<T> left, T scalar) => throw new NotSupportedException();
+        protected virtual void Divide(T left, Span<T> right, ReadOnlySpan<byte> rightValidity) => throw new NotSupportedException();
+        protected virtual void Modulo(Span<T> left, ReadOnlySpan<T> right) => throw new NotSupportedException();
+        protected virtual void Modulo(Span<T> left, T scalar) => throw new NotSupportedException();
+        protected virtual void Modulo(T left, Span<T> right) => throw new NotSupportedException();
+        protected virtual void And(Span<T> left, ReadOnlySpan<T> right) => throw new NotSupportedException();
+        protected virtual void And(Span<T> left, T scalar) => throw new NotSupportedException();
+        protected virtual void And(T left, Span<T> right) => throw new NotSupportedException();
+        protected virtual void Or(Span<T> left, ReadOnlySpan<T> right) => throw new NotSupportedException();
+        protected virtual void Or(Span<T> left, T scalar) => throw new NotSupportedException();
+        protected virtual void Or(T left, Span<T> right) => throw new NotSupportedException();
+        protected virtual void Xor(Span<T> left, ReadOnlySpan<T> right) => throw new NotSupportedException();
+        protected virtual void Xor(Span<T> left, T scalar) => throw new NotSupportedException();
+        protected virtual void Xor(T left, Span<T> right) => throw new NotSupportedException();
+        protected virtual void LeftShift(Span<T> left, int right) => throw new NotSupportedException();
+        protected virtual void RightShift(Span<T> left, int right) => throw new NotSupportedException();
+        protected virtual void ElementwiseEquals(ReadOnlySpan<T> left, ReadOnlySpan<T> right, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+        protected virtual void ElementwiseEquals(ReadOnlySpan<T> left, T right, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+        protected virtual void ElementwiseNotEquals(ReadOnlySpan<T> left, ReadOnlySpan<T> right, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+        protected virtual void ElementwiseNotEquals(ReadOnlySpan<T> left, T right, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+        protected virtual void ElementwiseGreaterThanOrEqual(ReadOnlySpan<T> left, ReadOnlySpan<T> right, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+        protected virtual void ElementwiseGreaterThanOrEqual(ReadOnlySpan<T> left, T right, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+        protected virtual void ElementwiseLessThanOrEqual(ReadOnlySpan<T> left, ReadOnlySpan<T> right, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+        protected virtual void ElementwiseLessThanOrEqual(ReadOnlySpan<T> left, T right, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+        protected virtual void ElementwiseGreaterThan(ReadOnlySpan<T> left, ReadOnlySpan<T> right, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+        protected virtual void ElementwiseGreaterThan(ReadOnlySpan<T> left, T right, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+        protected virtual void ElementwiseLessThan(ReadOnlySpan<T> left, ReadOnlySpan<T> right, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+        protected virtual void ElementwiseLessThan(ReadOnlySpan<T> left, T right, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
 
     }
 
@@ -105,7194 +203,3117 @@ public static IPrimitiveDataFrameColumnArithmetic<T> GetArithmetic<T>()
             where T : unmanaged
         {
             if (typeof(T) == typeof(bool))
-            {
                 return (IPrimitiveDataFrameColumnArithmetic<T>)new BoolArithmetic();
-            }
             else if (typeof(T) == typeof(byte))
-            {
                 return (IPrimitiveDataFrameColumnArithmetic<T>)new ByteArithmetic();
-            }
             else if (typeof(T) == typeof(char))
-            {
                 return (IPrimitiveDataFrameColumnArithmetic<T>)new CharArithmetic();
-            }
             else if (typeof(T) == typeof(decimal))
-            {
                 return (IPrimitiveDataFrameColumnArithmetic<T>)new DecimalArithmetic();
-            }
             else if (typeof(T) == typeof(double))
-            {
                 return (IPrimitiveDataFrameColumnArithmetic<T>)new DoubleArithmetic();
-            }
             else if (typeof(T) == typeof(float))
-            {
                 return (IPrimitiveDataFrameColumnArithmetic<T>)new FloatArithmetic();
-            }
             else if (typeof(T) == typeof(int))
-            {
                 return (IPrimitiveDataFrameColumnArithmetic<T>)new IntArithmetic();
-            }
             else if (typeof(T) == typeof(long))
-            {
                 return (IPrimitiveDataFrameColumnArithmetic<T>)new LongArithmetic();
-            }
             else if (typeof(T) == typeof(sbyte))
-            {
                 return (IPrimitiveDataFrameColumnArithmetic<T>)new SByteArithmetic();
-            }
             else if (typeof(T) == typeof(short))
-            {
                 return (IPrimitiveDataFrameColumnArithmetic<T>)new ShortArithmetic();
-            }
             else if (typeof(T) == typeof(uint))
-            {
                 return (IPrimitiveDataFrameColumnArithmetic<T>)new UIntArithmetic();
-            }
             else if (typeof(T) == typeof(ulong))
-            {
                 return (IPrimitiveDataFrameColumnArithmetic<T>)new ULongArithmetic();
-            }
             else if (typeof(T) == typeof(ushort))
-            {
                 return (IPrimitiveDataFrameColumnArithmetic<T>)new UShortArithmetic();
-            }
             else if (typeof(T) == typeof(DateTime))
-            {
                 return (IPrimitiveDataFrameColumnArithmetic<T>)new DateTimeArithmetic();
-            }
             throw new NotSupportedException();
         }
     }
+
     internal class BoolArithmetic : PrimitiveDataFrameColumnArithmetic<bool>
     {
 
-        public override void And(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
+        protected override void And(Span<bool> left, ReadOnlySpan<bool> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (bool)(span[i] & otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (bool)(left[i] & right[i]);
         }
 
-        public override void And(PrimitiveColumnContainer<bool> column, bool scalar)
+        protected override void And(Span<bool> left, bool right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (bool)(span[i] & scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (bool)(left[i] & right);
         }
 
-        public override void And(bool scalar, PrimitiveColumnContainer<bool> column)
+        protected override void And(bool left, Span<bool> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (bool)(scalar & span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (bool)(left & right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
+        protected override void Or(Span<bool> left, ReadOnlySpan<bool> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (bool)(span[i] | otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (bool)(left[i] | right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<bool> column, bool scalar)
+        protected override void Or(Span<bool> left, bool right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (bool)(span[i] | scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (bool)(left[i] | right);
         }
 
-        public override void Or(bool scalar, PrimitiveColumnContainer<bool> column)
+        protected override void Or(bool left, Span<bool> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (bool)(scalar | span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (bool)(left | right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
+        protected override void Xor(Span<bool> left, ReadOnlySpan<bool> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (bool)(span[i] ^ otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (bool)(left[i] ^ right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<bool> column, bool scalar)
+        protected override void Xor(Span<bool> left, bool right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (bool)(span[i] ^ scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (bool)(left[i] ^ right);
         }
 
-        public override void Xor(bool scalar, PrimitiveColumnContainer<bool> column)
+        protected override void Xor(bool left, Span<bool> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (bool)(scalar ^ span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (bool)(left ^ right[i]);
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
+        protected override void ElementwiseEquals(ReadOnlySpan<bool> left, ReadOnlySpan<bool> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == otherSpan[i]);
-                }
+                result[i + offset] = (left[i] == right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<bool> column, bool scalar)
+        protected override void ElementwiseEquals(ReadOnlySpan<bool> left, bool right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == scalar);
-                }
+                result[i + offset] = (left[i] == right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<bool> left, ReadOnlySpan<bool> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != otherSpan[i]);
-                }
+                result[i + offset] = (left[i] != right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<bool> column, bool scalar)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<bool> left, bool right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != scalar);
-                }
+                result[i + offset] = (left[i] != right);
             }
-            return ret;
         }
     }
     internal class ByteArithmetic : PrimitiveDataFrameColumnArithmetic<byte>
     {
 
-        public override void Add(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+        protected override void Add(Span<byte> left, ReadOnlySpan<byte> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (byte)(span[i] + otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (byte)(left[i] + right[i]);
         }
 
-        public override void Add(PrimitiveColumnContainer<byte> column, byte scalar)
+        protected override void Add(Span<byte> left, byte right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (byte)(span[i] + scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (byte)(left[i] + right);
         }
 
-        public override void Add(byte scalar, PrimitiveColumnContainer<byte> column)
+        protected override void Add(byte left, Span<byte> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (byte)(scalar + span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (byte)(left + right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+        protected override void Subtract(Span<byte> left, ReadOnlySpan<byte> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (byte)(span[i] - otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (byte)(left[i] - right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<byte> column, byte scalar)
+        protected override void Subtract(Span<byte> left, byte right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (byte)(span[i] - scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (byte)(left[i] - right);
         }
 
-        public override void Subtract(byte scalar, PrimitiveColumnContainer<byte> column)
+        protected override void Subtract(byte left, Span<byte> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (byte)(scalar - span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (byte)(left - right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+        protected override void Multiply(Span<byte> left, ReadOnlySpan<byte> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (byte)(span[i] * otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (byte)(left[i] * right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<byte> column, byte scalar)
+        protected override void Multiply(Span<byte> left, byte right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (byte)(span[i] * scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (byte)(left[i] * right);
         }
 
-        public override void Multiply(byte scalar, PrimitiveColumnContainer<byte> column)
+        protected override void Multiply(byte left, Span<byte> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (byte)(scalar * span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (byte)(left * right[i]);
         }
 
-        public override void Divide(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+        protected override void Divide(Span<byte> left, Span<byte> leftValidity, ReadOnlySpan<byte> right, ReadOnlySpan<byte> rightValidity)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (byte)(span[i] / otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    left[i] = (byte)(left[i] / right[i]);
+                else
+                    BitUtility.ClearBit(leftValidity, i);
             }
         }
 
-        public override void Divide(PrimitiveColumnContainer<byte> column, byte scalar)
+        protected override void Divide(Span<byte> left, byte right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (byte)(span[i] / scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (byte)(left[i] / right);
         }
 
-        public override void Divide(byte scalar, PrimitiveColumnContainer<byte> column)
+        protected override void Divide(byte left, Span<byte> right, ReadOnlySpan<byte> rightValidity)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < right.Length; i++)
             {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (byte)(scalar / span[i]);
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    right[i] = (byte)(left / right[i]);
             }
         }
 
-        public override void Modulo(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+        protected override void Modulo(Span<byte> left, ReadOnlySpan<byte> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (byte)(span[i] % otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (byte)(left[i] % right[i]);
         }
 
-        public override void Modulo(PrimitiveColumnContainer<byte> column, byte scalar)
+        protected override void Modulo(Span<byte> left, byte right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (byte)(span[i] % scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (byte)(left[i] % right);
         }
 
-        public override void Modulo(byte scalar, PrimitiveColumnContainer<byte> column)
+        protected override void Modulo(byte left, Span<byte> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (byte)(scalar % span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (byte)(left % right[i]);
         }
 
-        public override void And(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+        protected override void And(Span<byte> left, ReadOnlySpan<byte> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (byte)(span[i] & otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (byte)(left[i] & right[i]);
         }
 
-        public override void And(PrimitiveColumnContainer<byte> column, byte scalar)
+        protected override void And(Span<byte> left, byte right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (byte)(span[i] & scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (byte)(left[i] & right);
         }
 
-        public override void And(byte scalar, PrimitiveColumnContainer<byte> column)
+        protected override void And(byte left, Span<byte> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (byte)(scalar & span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (byte)(left & right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+        protected override void Or(Span<byte> left, ReadOnlySpan<byte> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (byte)(span[i] | otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (byte)(left[i] | right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<byte> column, byte scalar)
+        protected override void Or(Span<byte> left, byte right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (byte)(span[i] | scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (byte)(left[i] | right);
         }
 
-        public override void Or(byte scalar, PrimitiveColumnContainer<byte> column)
+        protected override void Or(byte left, Span<byte> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (byte)(scalar | span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (byte)(left | right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+        protected override void Xor(Span<byte> left, ReadOnlySpan<byte> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (byte)(span[i] ^ otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (byte)(left[i] ^ right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<byte> column, byte scalar)
+        protected override void Xor(Span<byte> left, byte right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (byte)(span[i] ^ scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (byte)(left[i] ^ right);
         }
 
-        public override void Xor(byte scalar, PrimitiveColumnContainer<byte> column)
+        protected override void Xor(byte left, Span<byte> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (byte)(scalar ^ span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (byte)(left ^ right[i]);
         }
 
-        public override void LeftShift(PrimitiveColumnContainer<byte> column, int value)
+        protected override void LeftShift(Span<byte> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (byte)(span[i] << value);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (byte)(left[i] << right);
         }
 
-        public override void RightShift(PrimitiveColumnContainer<byte> column, int value)
+        protected override void RightShift(Span<byte> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (byte)(span[i] >> value);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (byte)(left[i] >> right);
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+        protected override void ElementwiseEquals(ReadOnlySpan<byte> left, ReadOnlySpan<byte> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == otherSpan[i]);
-                }
+                result[i + offset] = (left[i] == right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<byte> column, byte scalar)
+        protected override void ElementwiseEquals(ReadOnlySpan<byte> left, byte right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == scalar);
-                }
+                result[i + offset] = (left[i] == right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<byte> left, ReadOnlySpan<byte> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != otherSpan[i]);
-                }
+                result[i + offset] = (left[i] != right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<byte> column, byte scalar)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<byte> left, byte right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != scalar);
-                }
+                result[i + offset] = (left[i] != right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<byte> left, ReadOnlySpan<byte> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] >= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<byte> column, byte scalar)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<byte> left, byte right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= scalar);
-                }
+                result[i + offset] = (left[i] >= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<byte> left, ReadOnlySpan<byte> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] <= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<byte> column, byte scalar)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<byte> left, byte right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= scalar);
-                }
+                result[i + offset] = (left[i] <= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<byte> left, ReadOnlySpan<byte> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > otherSpan[i]);
-                }
+                result[i + offset] = (left[i] > right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<byte> column, byte scalar)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<byte> left, byte right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > scalar);
-                }
+                result[i + offset] = (left[i] > right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+        protected override void ElementwiseLessThan(ReadOnlySpan<byte> left, ReadOnlySpan<byte> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < otherSpan[i]);
-                }
+                result[i + offset] = (left[i] < right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<byte> column, byte scalar)
+        protected override void ElementwiseLessThan(ReadOnlySpan<byte> left, byte right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < scalar);
-                }
+                result[i + offset] = (left[i] < right);
             }
-            return ret;
         }
     }
     internal class CharArithmetic : PrimitiveDataFrameColumnArithmetic<char>
     {
 
-        public override void Add(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+        protected override void Add(Span<char> left, ReadOnlySpan<char> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (char)(span[i] + otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (char)(left[i] + right[i]);
         }
 
-        public override void Add(PrimitiveColumnContainer<char> column, char scalar)
+        protected override void Add(Span<char> left, char right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (char)(span[i] + scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (char)(left[i] + right);
         }
 
-        public override void Add(char scalar, PrimitiveColumnContainer<char> column)
+        protected override void Add(char left, Span<char> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (char)(scalar + span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (char)(left + right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+        protected override void Subtract(Span<char> left, ReadOnlySpan<char> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (char)(span[i] - otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (char)(left[i] - right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<char> column, char scalar)
+        protected override void Subtract(Span<char> left, char right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (char)(span[i] - scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (char)(left[i] - right);
         }
 
-        public override void Subtract(char scalar, PrimitiveColumnContainer<char> column)
+        protected override void Subtract(char left, Span<char> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (char)(scalar - span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (char)(left - right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+        protected override void Multiply(Span<char> left, ReadOnlySpan<char> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (char)(span[i] * otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (char)(left[i] * right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<char> column, char scalar)
+        protected override void Multiply(Span<char> left, char right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (char)(span[i] * scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (char)(left[i] * right);
         }
 
-        public override void Multiply(char scalar, PrimitiveColumnContainer<char> column)
+        protected override void Multiply(char left, Span<char> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (char)(scalar * span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (char)(left * right[i]);
         }
 
-        public override void Divide(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+        protected override void Divide(Span<char> left, Span<byte> leftValidity, ReadOnlySpan<char> right, ReadOnlySpan<byte> rightValidity)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (char)(span[i] / otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    left[i] = (char)(left[i] / right[i]);
+                else
+                    BitUtility.ClearBit(leftValidity, i);
             }
         }
 
-        public override void Divide(PrimitiveColumnContainer<char> column, char scalar)
+        protected override void Divide(Span<char> left, char right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (char)(span[i] / scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (char)(left[i] / right);
         }
 
-        public override void Divide(char scalar, PrimitiveColumnContainer<char> column)
+        protected override void Divide(char left, Span<char> right, ReadOnlySpan<byte> rightValidity)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < right.Length; i++)
             {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (char)(scalar / span[i]);
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    right[i] = (char)(left / right[i]);
             }
         }
 
-        public override void Modulo(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+        protected override void Modulo(Span<char> left, ReadOnlySpan<char> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (char)(span[i] % otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (char)(left[i] % right[i]);
         }
 
-        public override void Modulo(PrimitiveColumnContainer<char> column, char scalar)
+        protected override void Modulo(Span<char> left, char right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (char)(span[i] % scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (char)(left[i] % right);
         }
 
-        public override void Modulo(char scalar, PrimitiveColumnContainer<char> column)
+        protected override void Modulo(char left, Span<char> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (char)(scalar % span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (char)(left % right[i]);
         }
 
-        public override void And(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+        protected override void And(Span<char> left, ReadOnlySpan<char> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (char)(span[i] & otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (char)(left[i] & right[i]);
         }
 
-        public override void And(PrimitiveColumnContainer<char> column, char scalar)
+        protected override void And(Span<char> left, char right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (char)(span[i] & scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (char)(left[i] & right);
         }
 
-        public override void And(char scalar, PrimitiveColumnContainer<char> column)
+        protected override void And(char left, Span<char> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (char)(scalar & span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (char)(left & right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+        protected override void Or(Span<char> left, ReadOnlySpan<char> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (char)(span[i] | otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (char)(left[i] | right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<char> column, char scalar)
+        protected override void Or(Span<char> left, char right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (char)(span[i] | scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (char)(left[i] | right);
         }
 
-        public override void Or(char scalar, PrimitiveColumnContainer<char> column)
+        protected override void Or(char left, Span<char> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (char)(scalar | span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (char)(left | right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+        protected override void Xor(Span<char> left, ReadOnlySpan<char> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (char)(span[i] ^ otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (char)(left[i] ^ right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<char> column, char scalar)
+        protected override void Xor(Span<char> left, char right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (char)(span[i] ^ scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (char)(left[i] ^ right);
         }
 
-        public override void Xor(char scalar, PrimitiveColumnContainer<char> column)
+        protected override void Xor(char left, Span<char> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (char)(scalar ^ span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (char)(left ^ right[i]);
         }
 
-        public override void LeftShift(PrimitiveColumnContainer<char> column, int value)
+        protected override void LeftShift(Span<char> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (char)(span[i] << value);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (char)(left[i] << right);
         }
 
-        public override void RightShift(PrimitiveColumnContainer<char> column, int value)
+        protected override void RightShift(Span<char> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (char)(span[i] >> value);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (char)(left[i] >> right);
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+        protected override void ElementwiseEquals(ReadOnlySpan<char> left, ReadOnlySpan<char> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == otherSpan[i]);
-                }
+                result[i + offset] = (left[i] == right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<char> column, char scalar)
+        protected override void ElementwiseEquals(ReadOnlySpan<char> left, char right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == scalar);
-                }
+                result[i + offset] = (left[i] == right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<char> left, ReadOnlySpan<char> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != otherSpan[i]);
-                }
+                result[i + offset] = (left[i] != right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<char> column, char scalar)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<char> left, char right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != scalar);
-                }
+                result[i + offset] = (left[i] != right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<char> left, ReadOnlySpan<char> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] >= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<char> column, char scalar)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<char> left, char right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= scalar);
-                }
+                result[i + offset] = (left[i] >= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<char> left, ReadOnlySpan<char> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] <= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<char> column, char scalar)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<char> left, char right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= scalar);
-                }
+                result[i + offset] = (left[i] <= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<char> left, ReadOnlySpan<char> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > otherSpan[i]);
-                }
+                result[i + offset] = (left[i] > right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<char> column, char scalar)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<char> left, char right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > scalar);
-                }
+                result[i + offset] = (left[i] > right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+        protected override void ElementwiseLessThan(ReadOnlySpan<char> left, ReadOnlySpan<char> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < otherSpan[i]);
-                }
+                result[i + offset] = (left[i] < right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<char> column, char scalar)
+        protected override void ElementwiseLessThan(ReadOnlySpan<char> left, char right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < scalar);
-                }
+                result[i + offset] = (left[i] < right);
             }
-            return ret;
         }
     }
     internal class DecimalArithmetic : PrimitiveDataFrameColumnArithmetic<decimal>
     {
 
-        public override void Add(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
+        protected override void Add(Span<decimal> left, ReadOnlySpan<decimal> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (decimal)(span[i] + otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (decimal)(left[i] + right[i]);
         }
 
-        public override void Add(PrimitiveColumnContainer<decimal> column, decimal scalar)
+        protected override void Add(Span<decimal> left, decimal right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (decimal)(span[i] + scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (decimal)(left[i] + right);
         }
 
-        public override void Add(decimal scalar, PrimitiveColumnContainer<decimal> column)
+        protected override void Add(decimal left, Span<decimal> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (decimal)(scalar + span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (decimal)(left + right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
+        protected override void Subtract(Span<decimal> left, ReadOnlySpan<decimal> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (decimal)(span[i] - otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (decimal)(left[i] - right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<decimal> column, decimal scalar)
+        protected override void Subtract(Span<decimal> left, decimal right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (decimal)(span[i] - scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (decimal)(left[i] - right);
         }
 
-        public override void Subtract(decimal scalar, PrimitiveColumnContainer<decimal> column)
+        protected override void Subtract(decimal left, Span<decimal> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (decimal)(scalar - span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (decimal)(left - right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
+        protected override void Multiply(Span<decimal> left, ReadOnlySpan<decimal> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (decimal)(span[i] * otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (decimal)(left[i] * right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<decimal> column, decimal scalar)
+        protected override void Multiply(Span<decimal> left, decimal right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (decimal)(span[i] * scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (decimal)(left[i] * right);
         }
 
-        public override void Multiply(decimal scalar, PrimitiveColumnContainer<decimal> column)
+        protected override void Multiply(decimal left, Span<decimal> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (decimal)(scalar * span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (decimal)(left * right[i]);
         }
 
-        public override void Divide(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
+        protected override void Divide(Span<decimal> left, Span<byte> leftValidity, ReadOnlySpan<decimal> right, ReadOnlySpan<byte> rightValidity)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (decimal)(span[i] / otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    left[i] = (decimal)(left[i] / right[i]);
+                else
+                    BitUtility.ClearBit(leftValidity, i);
             }
         }
 
-        public override void Divide(PrimitiveColumnContainer<decimal> column, decimal scalar)
+        protected override void Divide(Span<decimal> left, decimal right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (decimal)(span[i] / scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (decimal)(left[i] / right);
         }
 
-        public override void Divide(decimal scalar, PrimitiveColumnContainer<decimal> column)
+        protected override void Divide(decimal left, Span<decimal> right, ReadOnlySpan<byte> rightValidity)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < right.Length; i++)
             {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (decimal)(scalar / span[i]);
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    right[i] = (decimal)(left / right[i]);
             }
         }
 
-        public override void Modulo(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
+        protected override void Modulo(Span<decimal> left, ReadOnlySpan<decimal> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (decimal)(span[i] % otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (decimal)(left[i] % right[i]);
         }
 
-        public override void Modulo(PrimitiveColumnContainer<decimal> column, decimal scalar)
+        protected override void Modulo(Span<decimal> left, decimal right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (decimal)(span[i] % scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (decimal)(left[i] % right);
         }
 
-        public override void Modulo(decimal scalar, PrimitiveColumnContainer<decimal> column)
+        protected override void Modulo(decimal left, Span<decimal> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (decimal)(scalar % span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (decimal)(left % right[i]);
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
+        protected override void ElementwiseEquals(ReadOnlySpan<decimal> left, ReadOnlySpan<decimal> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == otherSpan[i]);
-                }
+                result[i + offset] = (left[i] == right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<decimal> column, decimal scalar)
+        protected override void ElementwiseEquals(ReadOnlySpan<decimal> left, decimal right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == scalar);
-                }
+                result[i + offset] = (left[i] == right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<decimal> left, ReadOnlySpan<decimal> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != otherSpan[i]);
-                }
+                result[i + offset] = (left[i] != right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<decimal> column, decimal scalar)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<decimal> left, decimal right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != scalar);
-                }
+                result[i + offset] = (left[i] != right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<decimal> left, ReadOnlySpan<decimal> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] >= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<decimal> column, decimal scalar)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<decimal> left, decimal right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= scalar);
-                }
+                result[i + offset] = (left[i] >= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<decimal> left, ReadOnlySpan<decimal> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] <= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<decimal> column, decimal scalar)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<decimal> left, decimal right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= scalar);
-                }
+                result[i + offset] = (left[i] <= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<decimal> left, ReadOnlySpan<decimal> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > otherSpan[i]);
-                }
+                result[i + offset] = (left[i] > right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<decimal> column, decimal scalar)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<decimal> left, decimal right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > scalar);
-                }
+                result[i + offset] = (left[i] > right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
+        protected override void ElementwiseLessThan(ReadOnlySpan<decimal> left, ReadOnlySpan<decimal> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < otherSpan[i]);
-                }
+                result[i + offset] = (left[i] < right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<decimal> column, decimal scalar)
+        protected override void ElementwiseLessThan(ReadOnlySpan<decimal> left, decimal right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < scalar);
-                }
+                result[i + offset] = (left[i] < right);
             }
-            return ret;
         }
     }
     internal class DoubleArithmetic : PrimitiveDataFrameColumnArithmetic<double>
     {
 
-        public override void Add(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
+        protected override void Add(Span<double> left, ReadOnlySpan<double> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (double)(span[i] + otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (double)(left[i] + right[i]);
         }
 
-        public override void Add(PrimitiveColumnContainer<double> column, double scalar)
+        protected override void Add(Span<double> left, double right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (double)(span[i] + scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (double)(left[i] + right);
         }
 
-        public override void Add(double scalar, PrimitiveColumnContainer<double> column)
+        protected override void Add(double left, Span<double> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (double)(scalar + span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (double)(left + right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
+        protected override void Subtract(Span<double> left, ReadOnlySpan<double> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (double)(span[i] - otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (double)(left[i] - right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<double> column, double scalar)
+        protected override void Subtract(Span<double> left, double right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (double)(span[i] - scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (double)(left[i] - right);
         }
 
-        public override void Subtract(double scalar, PrimitiveColumnContainer<double> column)
+        protected override void Subtract(double left, Span<double> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (double)(scalar - span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (double)(left - right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
+        protected override void Multiply(Span<double> left, ReadOnlySpan<double> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (double)(span[i] * otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (double)(left[i] * right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<double> column, double scalar)
+        protected override void Multiply(Span<double> left, double right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (double)(span[i] * scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (double)(left[i] * right);
         }
 
-        public override void Multiply(double scalar, PrimitiveColumnContainer<double> column)
+        protected override void Multiply(double left, Span<double> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (double)(scalar * span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (double)(left * right[i]);
         }
 
-        public override void Divide(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
+        protected override void Divide(Span<double> left, Span<byte> leftValidity, ReadOnlySpan<double> right, ReadOnlySpan<byte> rightValidity)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (double)(span[i] / otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    left[i] = (double)(left[i] / right[i]);
+                else
+                    BitUtility.ClearBit(leftValidity, i);
             }
         }
 
-        public override void Divide(PrimitiveColumnContainer<double> column, double scalar)
+        protected override void Divide(Span<double> left, double right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (double)(span[i] / scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (double)(left[i] / right);
         }
 
-        public override void Divide(double scalar, PrimitiveColumnContainer<double> column)
+        protected override void Divide(double left, Span<double> right, ReadOnlySpan<byte> rightValidity)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < right.Length; i++)
             {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (double)(scalar / span[i]);
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    right[i] = (double)(left / right[i]);
             }
         }
 
-        public override void Modulo(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
+        protected override void Modulo(Span<double> left, ReadOnlySpan<double> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (double)(span[i] % otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (double)(left[i] % right[i]);
         }
 
-        public override void Modulo(PrimitiveColumnContainer<double> column, double scalar)
+        protected override void Modulo(Span<double> left, double right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (double)(span[i] % scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (double)(left[i] % right);
         }
 
-        public override void Modulo(double scalar, PrimitiveColumnContainer<double> column)
+        protected override void Modulo(double left, Span<double> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (double)(scalar % span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (double)(left % right[i]);
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
+        protected override void ElementwiseEquals(ReadOnlySpan<double> left, ReadOnlySpan<double> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == otherSpan[i]);
-                }
+                result[i + offset] = (left[i] == right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<double> column, double scalar)
+        protected override void ElementwiseEquals(ReadOnlySpan<double> left, double right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == scalar);
-                }
+                result[i + offset] = (left[i] == right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<double> left, ReadOnlySpan<double> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != otherSpan[i]);
-                }
+                result[i + offset] = (left[i] != right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<double> column, double scalar)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<double> left, double right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != scalar);
-                }
+                result[i + offset] = (left[i] != right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<double> left, ReadOnlySpan<double> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] >= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<double> column, double scalar)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<double> left, double right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= scalar);
-                }
+                result[i + offset] = (left[i] >= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<double> left, ReadOnlySpan<double> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] <= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<double> column, double scalar)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<double> left, double right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= scalar);
-                }
+                result[i + offset] = (left[i] <= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<double> left, ReadOnlySpan<double> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > otherSpan[i]);
-                }
+                result[i + offset] = (left[i] > right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<double> column, double scalar)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<double> left, double right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > scalar);
-                }
+                result[i + offset] = (left[i] > right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
+        protected override void ElementwiseLessThan(ReadOnlySpan<double> left, ReadOnlySpan<double> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < otherSpan[i]);
-                }
+                result[i + offset] = (left[i] < right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<double> column, double scalar)
+        protected override void ElementwiseLessThan(ReadOnlySpan<double> left, double right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < scalar);
-                }
+                result[i + offset] = (left[i] < right);
             }
-            return ret;
         }
     }
     internal class FloatArithmetic : PrimitiveDataFrameColumnArithmetic<float>
     {
 
-        public override void Add(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
+        protected override void Add(Span<float> left, ReadOnlySpan<float> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (float)(span[i] + otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (float)(left[i] + right[i]);
         }
 
-        public override void Add(PrimitiveColumnContainer<float> column, float scalar)
+        protected override void Add(Span<float> left, float right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (float)(span[i] + scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (float)(left[i] + right);
         }
 
-        public override void Add(float scalar, PrimitiveColumnContainer<float> column)
+        protected override void Add(float left, Span<float> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (float)(scalar + span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (float)(left + right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
+        protected override void Subtract(Span<float> left, ReadOnlySpan<float> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (float)(span[i] - otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (float)(left[i] - right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<float> column, float scalar)
+        protected override void Subtract(Span<float> left, float right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (float)(span[i] - scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (float)(left[i] - right);
         }
 
-        public override void Subtract(float scalar, PrimitiveColumnContainer<float> column)
+        protected override void Subtract(float left, Span<float> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (float)(scalar - span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (float)(left - right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
+        protected override void Multiply(Span<float> left, ReadOnlySpan<float> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (float)(span[i] * otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (float)(left[i] * right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<float> column, float scalar)
+        protected override void Multiply(Span<float> left, float right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (float)(span[i] * scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (float)(left[i] * right);
         }
 
-        public override void Multiply(float scalar, PrimitiveColumnContainer<float> column)
+        protected override void Multiply(float left, Span<float> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (float)(scalar * span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (float)(left * right[i]);
         }
 
-        public override void Divide(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
+        protected override void Divide(Span<float> left, Span<byte> leftValidity, ReadOnlySpan<float> right, ReadOnlySpan<byte> rightValidity)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (float)(span[i] / otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    left[i] = (float)(left[i] / right[i]);
+                else
+                    BitUtility.ClearBit(leftValidity, i);
             }
         }
 
-        public override void Divide(PrimitiveColumnContainer<float> column, float scalar)
+        protected override void Divide(Span<float> left, float right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (float)(span[i] / scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (float)(left[i] / right);
         }
 
-        public override void Divide(float scalar, PrimitiveColumnContainer<float> column)
+        protected override void Divide(float left, Span<float> right, ReadOnlySpan<byte> rightValidity)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < right.Length; i++)
             {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (float)(scalar / span[i]);
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    right[i] = (float)(left / right[i]);
             }
         }
 
-        public override void Modulo(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
+        protected override void Modulo(Span<float> left, ReadOnlySpan<float> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (float)(span[i] % otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (float)(left[i] % right[i]);
         }
 
-        public override void Modulo(PrimitiveColumnContainer<float> column, float scalar)
+        protected override void Modulo(Span<float> left, float right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (float)(span[i] % scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (float)(left[i] % right);
         }
 
-        public override void Modulo(float scalar, PrimitiveColumnContainer<float> column)
+        protected override void Modulo(float left, Span<float> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (float)(scalar % span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (float)(left % right[i]);
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
+        protected override void ElementwiseEquals(ReadOnlySpan<float> left, ReadOnlySpan<float> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == otherSpan[i]);
-                }
+                result[i + offset] = (left[i] == right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<float> column, float scalar)
+        protected override void ElementwiseEquals(ReadOnlySpan<float> left, float right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == scalar);
-                }
+                result[i + offset] = (left[i] == right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<float> left, ReadOnlySpan<float> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != otherSpan[i]);
-                }
+                result[i + offset] = (left[i] != right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<float> column, float scalar)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<float> left, float right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != scalar);
-                }
+                result[i + offset] = (left[i] != right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<float> left, ReadOnlySpan<float> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] >= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<float> column, float scalar)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<float> left, float right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= scalar);
-                }
+                result[i + offset] = (left[i] >= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<float> left, ReadOnlySpan<float> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] <= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<float> column, float scalar)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<float> left, float right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= scalar);
-                }
+                result[i + offset] = (left[i] <= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<float> left, ReadOnlySpan<float> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > otherSpan[i]);
-                }
+                result[i + offset] = (left[i] > right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<float> column, float scalar)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<float> left, float right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > scalar);
-                }
+                result[i + offset] = (left[i] > right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
+        protected override void ElementwiseLessThan(ReadOnlySpan<float> left, ReadOnlySpan<float> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < otherSpan[i]);
-                }
+                result[i + offset] = (left[i] < right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<float> column, float scalar)
+        protected override void ElementwiseLessThan(ReadOnlySpan<float> left, float right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < scalar);
-                }
+                result[i + offset] = (left[i] < right);
             }
-            return ret;
         }
     }
     internal class IntArithmetic : PrimitiveDataFrameColumnArithmetic<int>
     {
 
-        public override void Add(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+        protected override void Add(Span<int> left, ReadOnlySpan<int> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (int)(span[i] + otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (int)(left[i] + right[i]);
         }
 
-        public override void Add(PrimitiveColumnContainer<int> column, int scalar)
+        protected override void Add(Span<int> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (int)(span[i] + scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (int)(left[i] + right);
         }
 
-        public override void Add(int scalar, PrimitiveColumnContainer<int> column)
+        protected override void Add(int left, Span<int> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (int)(scalar + span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (int)(left + right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+        protected override void Subtract(Span<int> left, ReadOnlySpan<int> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (int)(span[i] - otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (int)(left[i] - right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<int> column, int scalar)
+        protected override void Subtract(Span<int> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (int)(span[i] - scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (int)(left[i] - right);
         }
 
-        public override void Subtract(int scalar, PrimitiveColumnContainer<int> column)
+        protected override void Subtract(int left, Span<int> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (int)(scalar - span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (int)(left - right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+        protected override void Multiply(Span<int> left, ReadOnlySpan<int> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (int)(span[i] * otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (int)(left[i] * right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<int> column, int scalar)
+        protected override void Multiply(Span<int> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (int)(span[i] * scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (int)(left[i] * right);
         }
 
-        public override void Multiply(int scalar, PrimitiveColumnContainer<int> column)
+        protected override void Multiply(int left, Span<int> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (int)(scalar * span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (int)(left * right[i]);
         }
 
-        public override void Divide(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+        protected override void Divide(Span<int> left, Span<byte> leftValidity, ReadOnlySpan<int> right, ReadOnlySpan<byte> rightValidity)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (int)(span[i] / otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    left[i] = (int)(left[i] / right[i]);
+                else
+                    BitUtility.ClearBit(leftValidity, i);
             }
         }
 
-        public override void Divide(PrimitiveColumnContainer<int> column, int scalar)
+        protected override void Divide(Span<int> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (int)(span[i] / scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (int)(left[i] / right);
         }
 
-        public override void Divide(int scalar, PrimitiveColumnContainer<int> column)
+        protected override void Divide(int left, Span<int> right, ReadOnlySpan<byte> rightValidity)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < right.Length; i++)
             {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (int)(scalar / span[i]);
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    right[i] = (int)(left / right[i]);
             }
         }
 
-        public override void Modulo(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+        protected override void Modulo(Span<int> left, ReadOnlySpan<int> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (int)(span[i] % otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (int)(left[i] % right[i]);
         }
 
-        public override void Modulo(PrimitiveColumnContainer<int> column, int scalar)
+        protected override void Modulo(Span<int> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (int)(span[i] % scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (int)(left[i] % right);
         }
 
-        public override void Modulo(int scalar, PrimitiveColumnContainer<int> column)
+        protected override void Modulo(int left, Span<int> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (int)(scalar % span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (int)(left % right[i]);
         }
 
-        public override void And(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+        protected override void And(Span<int> left, ReadOnlySpan<int> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (int)(span[i] & otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (int)(left[i] & right[i]);
         }
 
-        public override void And(PrimitiveColumnContainer<int> column, int scalar)
+        protected override void And(Span<int> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (int)(span[i] & scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (int)(left[i] & right);
         }
 
-        public override void And(int scalar, PrimitiveColumnContainer<int> column)
+        protected override void And(int left, Span<int> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (int)(scalar & span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (int)(left & right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+        protected override void Or(Span<int> left, ReadOnlySpan<int> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (int)(span[i] | otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (int)(left[i] | right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<int> column, int scalar)
+        protected override void Or(Span<int> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (int)(span[i] | scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (int)(left[i] | right);
         }
 
-        public override void Or(int scalar, PrimitiveColumnContainer<int> column)
+        protected override void Or(int left, Span<int> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (int)(scalar | span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (int)(left | right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+        protected override void Xor(Span<int> left, ReadOnlySpan<int> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (int)(span[i] ^ otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (int)(left[i] ^ right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<int> column, int scalar)
+        protected override void Xor(Span<int> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (int)(span[i] ^ scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (int)(left[i] ^ right);
         }
 
-        public override void Xor(int scalar, PrimitiveColumnContainer<int> column)
+        protected override void Xor(int left, Span<int> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (int)(scalar ^ span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (int)(left ^ right[i]);
         }
 
-        public override void LeftShift(PrimitiveColumnContainer<int> column, int value)
+        protected override void LeftShift(Span<int> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (int)(span[i] << value);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (int)(left[i] << right);
         }
 
-        public override void RightShift(PrimitiveColumnContainer<int> column, int value)
+        protected override void RightShift(Span<int> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (int)(span[i] >> value);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (int)(left[i] >> right);
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+        protected override void ElementwiseEquals(ReadOnlySpan<int> left, ReadOnlySpan<int> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == otherSpan[i]);
-                }
+                result[i + offset] = (left[i] == right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<int> column, int scalar)
+        protected override void ElementwiseEquals(ReadOnlySpan<int> left, int right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == scalar);
-                }
+                result[i + offset] = (left[i] == right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<int> left, ReadOnlySpan<int> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != otherSpan[i]);
-                }
+                result[i + offset] = (left[i] != right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<int> column, int scalar)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<int> left, int right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != scalar);
-                }
+                result[i + offset] = (left[i] != right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<int> left, ReadOnlySpan<int> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] >= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<int> column, int scalar)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<int> left, int right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= scalar);
-                }
+                result[i + offset] = (left[i] >= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<int> left, ReadOnlySpan<int> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] <= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<int> column, int scalar)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<int> left, int right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= scalar);
-                }
+                result[i + offset] = (left[i] <= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<int> left, ReadOnlySpan<int> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > otherSpan[i]);
-                }
+                result[i + offset] = (left[i] > right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<int> column, int scalar)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<int> left, int right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > scalar);
-                }
+                result[i + offset] = (left[i] > right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+        protected override void ElementwiseLessThan(ReadOnlySpan<int> left, ReadOnlySpan<int> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < otherSpan[i]);
-                }
+                result[i + offset] = (left[i] < right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<int> column, int scalar)
+        protected override void ElementwiseLessThan(ReadOnlySpan<int> left, int right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < scalar);
-                }
+                result[i + offset] = (left[i] < right);
             }
-            return ret;
         }
     }
     internal class LongArithmetic : PrimitiveDataFrameColumnArithmetic<long>
     {
 
-        public override void Add(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+        protected override void Add(Span<long> left, ReadOnlySpan<long> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (long)(span[i] + otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (long)(left[i] + right[i]);
         }
 
-        public override void Add(PrimitiveColumnContainer<long> column, long scalar)
+        protected override void Add(Span<long> left, long right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (long)(span[i] + scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (long)(left[i] + right);
         }
 
-        public override void Add(long scalar, PrimitiveColumnContainer<long> column)
+        protected override void Add(long left, Span<long> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (long)(scalar + span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (long)(left + right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+        protected override void Subtract(Span<long> left, ReadOnlySpan<long> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (long)(span[i] - otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (long)(left[i] - right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<long> column, long scalar)
+        protected override void Subtract(Span<long> left, long right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (long)(span[i] - scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (long)(left[i] - right);
         }
 
-        public override void Subtract(long scalar, PrimitiveColumnContainer<long> column)
+        protected override void Subtract(long left, Span<long> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (long)(scalar - span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (long)(left - right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+        protected override void Multiply(Span<long> left, ReadOnlySpan<long> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (long)(span[i] * otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (long)(left[i] * right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<long> column, long scalar)
+        protected override void Multiply(Span<long> left, long right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (long)(span[i] * scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (long)(left[i] * right);
         }
 
-        public override void Multiply(long scalar, PrimitiveColumnContainer<long> column)
+        protected override void Multiply(long left, Span<long> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (long)(scalar * span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (long)(left * right[i]);
         }
 
-        public override void Divide(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+        protected override void Divide(Span<long> left, Span<byte> leftValidity, ReadOnlySpan<long> right, ReadOnlySpan<byte> rightValidity)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (long)(span[i] / otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    left[i] = (long)(left[i] / right[i]);
+                else
+                    BitUtility.ClearBit(leftValidity, i);
             }
         }
 
-        public override void Divide(PrimitiveColumnContainer<long> column, long scalar)
+        protected override void Divide(Span<long> left, long right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (long)(span[i] / scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (long)(left[i] / right);
         }
 
-        public override void Divide(long scalar, PrimitiveColumnContainer<long> column)
+        protected override void Divide(long left, Span<long> right, ReadOnlySpan<byte> rightValidity)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < right.Length; i++)
             {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (long)(scalar / span[i]);
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    right[i] = (long)(left / right[i]);
             }
         }
 
-        public override void Modulo(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+        protected override void Modulo(Span<long> left, ReadOnlySpan<long> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (long)(span[i] % otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (long)(left[i] % right[i]);
         }
 
-        public override void Modulo(PrimitiveColumnContainer<long> column, long scalar)
+        protected override void Modulo(Span<long> left, long right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (long)(span[i] % scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (long)(left[i] % right);
         }
 
-        public override void Modulo(long scalar, PrimitiveColumnContainer<long> column)
+        protected override void Modulo(long left, Span<long> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (long)(scalar % span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (long)(left % right[i]);
         }
 
-        public override void And(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+        protected override void And(Span<long> left, ReadOnlySpan<long> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (long)(span[i] & otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (long)(left[i] & right[i]);
         }
 
-        public override void And(PrimitiveColumnContainer<long> column, long scalar)
+        protected override void And(Span<long> left, long right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (long)(span[i] & scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (long)(left[i] & right);
         }
 
-        public override void And(long scalar, PrimitiveColumnContainer<long> column)
+        protected override void And(long left, Span<long> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (long)(scalar & span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (long)(left & right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+        protected override void Or(Span<long> left, ReadOnlySpan<long> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (long)(span[i] | otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (long)(left[i] | right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<long> column, long scalar)
+        protected override void Or(Span<long> left, long right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (long)(span[i] | scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (long)(left[i] | right);
         }
 
-        public override void Or(long scalar, PrimitiveColumnContainer<long> column)
+        protected override void Or(long left, Span<long> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (long)(scalar | span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (long)(left | right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+        protected override void Xor(Span<long> left, ReadOnlySpan<long> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (long)(span[i] ^ otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (long)(left[i] ^ right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<long> column, long scalar)
+        protected override void Xor(Span<long> left, long right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (long)(span[i] ^ scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (long)(left[i] ^ right);
         }
 
-        public override void Xor(long scalar, PrimitiveColumnContainer<long> column)
+        protected override void Xor(long left, Span<long> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (long)(scalar ^ span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (long)(left ^ right[i]);
         }
 
-        public override void LeftShift(PrimitiveColumnContainer<long> column, int value)
+        protected override void LeftShift(Span<long> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (long)(span[i] << value);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (long)(left[i] << right);
         }
 
-        public override void RightShift(PrimitiveColumnContainer<long> column, int value)
+        protected override void RightShift(Span<long> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (long)(span[i] >> value);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (long)(left[i] >> right);
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+        protected override void ElementwiseEquals(ReadOnlySpan<long> left, ReadOnlySpan<long> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == otherSpan[i]);
-                }
+                result[i + offset] = (left[i] == right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<long> column, long scalar)
+        protected override void ElementwiseEquals(ReadOnlySpan<long> left, long right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == scalar);
-                }
+                result[i + offset] = (left[i] == right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<long> left, ReadOnlySpan<long> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != otherSpan[i]);
-                }
+                result[i + offset] = (left[i] != right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<long> column, long scalar)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<long> left, long right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != scalar);
-                }
+                result[i + offset] = (left[i] != right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<long> left, ReadOnlySpan<long> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] >= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<long> column, long scalar)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<long> left, long right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= scalar);
-                }
+                result[i + offset] = (left[i] >= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<long> left, ReadOnlySpan<long> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] <= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<long> column, long scalar)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<long> left, long right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= scalar);
-                }
+                result[i + offset] = (left[i] <= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<long> left, ReadOnlySpan<long> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > otherSpan[i]);
-                }
+                result[i + offset] = (left[i] > right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<long> column, long scalar)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<long> left, long right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > scalar);
-                }
+                result[i + offset] = (left[i] > right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+        protected override void ElementwiseLessThan(ReadOnlySpan<long> left, ReadOnlySpan<long> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < otherSpan[i]);
-                }
+                result[i + offset] = (left[i] < right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<long> column, long scalar)
+        protected override void ElementwiseLessThan(ReadOnlySpan<long> left, long right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < scalar);
-                }
+                result[i + offset] = (left[i] < right);
             }
-            return ret;
         }
     }
     internal class SByteArithmetic : PrimitiveDataFrameColumnArithmetic<sbyte>
     {
 
-        public override void Add(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+        protected override void Add(Span<sbyte> left, ReadOnlySpan<sbyte> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (sbyte)(span[i] + otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (sbyte)(left[i] + right[i]);
         }
 
-        public override void Add(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+        protected override void Add(Span<sbyte> left, sbyte right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (sbyte)(span[i] + scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (sbyte)(left[i] + right);
         }
 
-        public override void Add(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
+        protected override void Add(sbyte left, Span<sbyte> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (sbyte)(scalar + span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (sbyte)(left + right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+        protected override void Subtract(Span<sbyte> left, ReadOnlySpan<sbyte> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (sbyte)(span[i] - otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (sbyte)(left[i] - right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+        protected override void Subtract(Span<sbyte> left, sbyte right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (sbyte)(span[i] - scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (sbyte)(left[i] - right);
         }
 
-        public override void Subtract(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
+        protected override void Subtract(sbyte left, Span<sbyte> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (sbyte)(scalar - span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (sbyte)(left - right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+        protected override void Multiply(Span<sbyte> left, ReadOnlySpan<sbyte> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (sbyte)(span[i] * otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (sbyte)(left[i] * right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+        protected override void Multiply(Span<sbyte> left, sbyte right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (sbyte)(span[i] * scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (sbyte)(left[i] * right);
         }
 
-        public override void Multiply(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
+        protected override void Multiply(sbyte left, Span<sbyte> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (sbyte)(scalar * span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (sbyte)(left * right[i]);
         }
 
-        public override void Divide(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+        protected override void Divide(Span<sbyte> left, Span<byte> leftValidity, ReadOnlySpan<sbyte> right, ReadOnlySpan<byte> rightValidity)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (sbyte)(span[i] / otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    left[i] = (sbyte)(left[i] / right[i]);
+                else
+                    BitUtility.ClearBit(leftValidity, i);
             }
         }
 
-        public override void Divide(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+        protected override void Divide(Span<sbyte> left, sbyte right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (sbyte)(span[i] / scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (sbyte)(left[i] / right);
         }
 
-        public override void Divide(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
+        protected override void Divide(sbyte left, Span<sbyte> right, ReadOnlySpan<byte> rightValidity)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < right.Length; i++)
             {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (sbyte)(scalar / span[i]);
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    right[i] = (sbyte)(left / right[i]);
             }
         }
 
-        public override void Modulo(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+        protected override void Modulo(Span<sbyte> left, ReadOnlySpan<sbyte> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (sbyte)(span[i] % otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (sbyte)(left[i] % right[i]);
         }
 
-        public override void Modulo(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+        protected override void Modulo(Span<sbyte> left, sbyte right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (sbyte)(span[i] % scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (sbyte)(left[i] % right);
         }
 
-        public override void Modulo(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
+        protected override void Modulo(sbyte left, Span<sbyte> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (sbyte)(scalar % span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (sbyte)(left % right[i]);
         }
 
-        public override void And(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+        protected override void And(Span<sbyte> left, ReadOnlySpan<sbyte> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (sbyte)(span[i] & otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (sbyte)(left[i] & right[i]);
         }
 
-        public override void And(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+        protected override void And(Span<sbyte> left, sbyte right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (sbyte)(span[i] & scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (sbyte)(left[i] & right);
         }
 
-        public override void And(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
+        protected override void And(sbyte left, Span<sbyte> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (sbyte)(scalar & span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (sbyte)(left & right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+        protected override void Or(Span<sbyte> left, ReadOnlySpan<sbyte> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (sbyte)(span[i] | otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (sbyte)(left[i] | right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+        protected override void Or(Span<sbyte> left, sbyte right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (sbyte)(span[i] | scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (sbyte)(left[i] | right);
         }
 
-        public override void Or(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
+        protected override void Or(sbyte left, Span<sbyte> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (sbyte)(scalar | span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (sbyte)(left | right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+        protected override void Xor(Span<sbyte> left, ReadOnlySpan<sbyte> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (sbyte)(span[i] ^ otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (sbyte)(left[i] ^ right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+        protected override void Xor(Span<sbyte> left, sbyte right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (sbyte)(span[i] ^ scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (sbyte)(left[i] ^ right);
         }
 
-        public override void Xor(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
+        protected override void Xor(sbyte left, Span<sbyte> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (sbyte)(scalar ^ span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (sbyte)(left ^ right[i]);
         }
 
-        public override void LeftShift(PrimitiveColumnContainer<sbyte> column, int value)
+        protected override void LeftShift(Span<sbyte> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (sbyte)(span[i] << value);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (sbyte)(left[i] << right);
         }
 
-        public override void RightShift(PrimitiveColumnContainer<sbyte> column, int value)
+        protected override void RightShift(Span<sbyte> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (sbyte)(span[i] >> value);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (sbyte)(left[i] >> right);
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+        protected override void ElementwiseEquals(ReadOnlySpan<sbyte> left, ReadOnlySpan<sbyte> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == otherSpan[i]);
-                }
+                result[i + offset] = (left[i] == right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+        protected override void ElementwiseEquals(ReadOnlySpan<sbyte> left, sbyte right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == scalar);
-                }
+                result[i + offset] = (left[i] == right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<sbyte> left, ReadOnlySpan<sbyte> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != otherSpan[i]);
-                }
+                result[i + offset] = (left[i] != right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<sbyte> left, sbyte right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != scalar);
-                }
+                result[i + offset] = (left[i] != right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<sbyte> left, ReadOnlySpan<sbyte> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] >= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<sbyte> left, sbyte right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= scalar);
-                }
+                result[i + offset] = (left[i] >= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<sbyte> left, ReadOnlySpan<sbyte> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] <= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<sbyte> left, sbyte right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= scalar);
-                }
+                result[i + offset] = (left[i] <= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<sbyte> left, ReadOnlySpan<sbyte> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > otherSpan[i]);
-                }
+                result[i + offset] = (left[i] > right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<sbyte> left, sbyte right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > scalar);
-                }
+                result[i + offset] = (left[i] > right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+        protected override void ElementwiseLessThan(ReadOnlySpan<sbyte> left, ReadOnlySpan<sbyte> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < otherSpan[i]);
-                }
+                result[i + offset] = (left[i] < right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+        protected override void ElementwiseLessThan(ReadOnlySpan<sbyte> left, sbyte right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < scalar);
-                }
+                result[i + offset] = (left[i] < right);
             }
-            return ret;
         }
     }
     internal class ShortArithmetic : PrimitiveDataFrameColumnArithmetic<short>
     {
 
-        public override void Add(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+        protected override void Add(Span<short> left, ReadOnlySpan<short> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (short)(span[i] + otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (short)(left[i] + right[i]);
         }
 
-        public override void Add(PrimitiveColumnContainer<short> column, short scalar)
+        protected override void Add(Span<short> left, short right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (short)(span[i] + scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (short)(left[i] + right);
         }
 
-        public override void Add(short scalar, PrimitiveColumnContainer<short> column)
+        protected override void Add(short left, Span<short> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (short)(scalar + span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (short)(left + right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+        protected override void Subtract(Span<short> left, ReadOnlySpan<short> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (short)(span[i] - otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (short)(left[i] - right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<short> column, short scalar)
+        protected override void Subtract(Span<short> left, short right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (short)(span[i] - scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (short)(left[i] - right);
         }
 
-        public override void Subtract(short scalar, PrimitiveColumnContainer<short> column)
+        protected override void Subtract(short left, Span<short> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (short)(scalar - span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (short)(left - right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+        protected override void Multiply(Span<short> left, ReadOnlySpan<short> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (short)(span[i] * otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (short)(left[i] * right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<short> column, short scalar)
+        protected override void Multiply(Span<short> left, short right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (short)(span[i] * scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (short)(left[i] * right);
         }
 
-        public override void Multiply(short scalar, PrimitiveColumnContainer<short> column)
+        protected override void Multiply(short left, Span<short> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (short)(scalar * span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (short)(left * right[i]);
         }
 
-        public override void Divide(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+        protected override void Divide(Span<short> left, Span<byte> leftValidity, ReadOnlySpan<short> right, ReadOnlySpan<byte> rightValidity)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (short)(span[i] / otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    left[i] = (short)(left[i] / right[i]);
+                else
+                    BitUtility.ClearBit(leftValidity, i);
             }
         }
 
-        public override void Divide(PrimitiveColumnContainer<short> column, short scalar)
+        protected override void Divide(Span<short> left, short right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (short)(span[i] / scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (short)(left[i] / right);
         }
 
-        public override void Divide(short scalar, PrimitiveColumnContainer<short> column)
+        protected override void Divide(short left, Span<short> right, ReadOnlySpan<byte> rightValidity)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < right.Length; i++)
             {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (short)(scalar / span[i]);
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    right[i] = (short)(left / right[i]);
             }
         }
 
-        public override void Modulo(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+        protected override void Modulo(Span<short> left, ReadOnlySpan<short> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (short)(span[i] % otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (short)(left[i] % right[i]);
         }
 
-        public override void Modulo(PrimitiveColumnContainer<short> column, short scalar)
+        protected override void Modulo(Span<short> left, short right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (short)(span[i] % scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (short)(left[i] % right);
         }
 
-        public override void Modulo(short scalar, PrimitiveColumnContainer<short> column)
+        protected override void Modulo(short left, Span<short> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (short)(scalar % span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (short)(left % right[i]);
         }
 
-        public override void And(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+        protected override void And(Span<short> left, ReadOnlySpan<short> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (short)(span[i] & otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (short)(left[i] & right[i]);
         }
 
-        public override void And(PrimitiveColumnContainer<short> column, short scalar)
+        protected override void And(Span<short> left, short right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (short)(span[i] & scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (short)(left[i] & right);
         }
 
-        public override void And(short scalar, PrimitiveColumnContainer<short> column)
+        protected override void And(short left, Span<short> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (short)(scalar & span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (short)(left & right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+        protected override void Or(Span<short> left, ReadOnlySpan<short> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (short)(span[i] | otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (short)(left[i] | right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<short> column, short scalar)
+        protected override void Or(Span<short> left, short right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (short)(span[i] | scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (short)(left[i] | right);
         }
 
-        public override void Or(short scalar, PrimitiveColumnContainer<short> column)
+        protected override void Or(short left, Span<short> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (short)(scalar | span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (short)(left | right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+        protected override void Xor(Span<short> left, ReadOnlySpan<short> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (short)(span[i] ^ otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (short)(left[i] ^ right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<short> column, short scalar)
+        protected override void Xor(Span<short> left, short right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (short)(span[i] ^ scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (short)(left[i] ^ right);
         }
 
-        public override void Xor(short scalar, PrimitiveColumnContainer<short> column)
+        protected override void Xor(short left, Span<short> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (short)(scalar ^ span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (short)(left ^ right[i]);
         }
 
-        public override void LeftShift(PrimitiveColumnContainer<short> column, int value)
+        protected override void LeftShift(Span<short> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (short)(span[i] << value);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (short)(left[i] << right);
         }
 
-        public override void RightShift(PrimitiveColumnContainer<short> column, int value)
+        protected override void RightShift(Span<short> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (short)(span[i] >> value);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (short)(left[i] >> right);
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+        protected override void ElementwiseEquals(ReadOnlySpan<short> left, ReadOnlySpan<short> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == otherSpan[i]);
-                }
+                result[i + offset] = (left[i] == right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<short> column, short scalar)
+        protected override void ElementwiseEquals(ReadOnlySpan<short> left, short right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == scalar);
-                }
+                result[i + offset] = (left[i] == right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<short> left, ReadOnlySpan<short> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != otherSpan[i]);
-                }
+                result[i + offset] = (left[i] != right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<short> column, short scalar)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<short> left, short right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != scalar);
-                }
+                result[i + offset] = (left[i] != right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<short> left, ReadOnlySpan<short> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] >= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<short> column, short scalar)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<short> left, short right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= scalar);
-                }
+                result[i + offset] = (left[i] >= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<short> left, ReadOnlySpan<short> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] <= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<short> column, short scalar)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<short> left, short right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= scalar);
-                }
+                result[i + offset] = (left[i] <= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<short> left, ReadOnlySpan<short> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > otherSpan[i]);
-                }
+                result[i + offset] = (left[i] > right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<short> column, short scalar)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<short> left, short right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > scalar);
-                }
+                result[i + offset] = (left[i] > right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+        protected override void ElementwiseLessThan(ReadOnlySpan<short> left, ReadOnlySpan<short> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < otherSpan[i]);
-                }
+                result[i + offset] = (left[i] < right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<short> column, short scalar)
+        protected override void ElementwiseLessThan(ReadOnlySpan<short> left, short right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < scalar);
-                }
+                result[i + offset] = (left[i] < right);
             }
-            return ret;
         }
     }
     internal class UIntArithmetic : PrimitiveDataFrameColumnArithmetic<uint>
     {
 
-        public override void Add(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+        protected override void Add(Span<uint> left, ReadOnlySpan<uint> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (uint)(span[i] + otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (uint)(left[i] + right[i]);
         }
 
-        public override void Add(PrimitiveColumnContainer<uint> column, uint scalar)
+        protected override void Add(Span<uint> left, uint right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (uint)(span[i] + scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (uint)(left[i] + right);
         }
 
-        public override void Add(uint scalar, PrimitiveColumnContainer<uint> column)
+        protected override void Add(uint left, Span<uint> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (uint)(scalar + span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (uint)(left + right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+        protected override void Subtract(Span<uint> left, ReadOnlySpan<uint> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (uint)(span[i] - otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (uint)(left[i] - right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<uint> column, uint scalar)
+        protected override void Subtract(Span<uint> left, uint right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (uint)(span[i] - scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (uint)(left[i] - right);
         }
 
-        public override void Subtract(uint scalar, PrimitiveColumnContainer<uint> column)
+        protected override void Subtract(uint left, Span<uint> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (uint)(scalar - span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (uint)(left - right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+        protected override void Multiply(Span<uint> left, ReadOnlySpan<uint> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (uint)(span[i] * otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (uint)(left[i] * right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<uint> column, uint scalar)
+        protected override void Multiply(Span<uint> left, uint right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (uint)(span[i] * scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (uint)(left[i] * right);
         }
 
-        public override void Multiply(uint scalar, PrimitiveColumnContainer<uint> column)
+        protected override void Multiply(uint left, Span<uint> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (uint)(scalar * span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (uint)(left * right[i]);
         }
 
-        public override void Divide(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+        protected override void Divide(Span<uint> left, Span<byte> leftValidity, ReadOnlySpan<uint> right, ReadOnlySpan<byte> rightValidity)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (uint)(span[i] / otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    left[i] = (uint)(left[i] / right[i]);
+                else
+                    BitUtility.ClearBit(leftValidity, i);
             }
         }
 
-        public override void Divide(PrimitiveColumnContainer<uint> column, uint scalar)
+        protected override void Divide(Span<uint> left, uint right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (uint)(span[i] / scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (uint)(left[i] / right);
         }
 
-        public override void Divide(uint scalar, PrimitiveColumnContainer<uint> column)
+        protected override void Divide(uint left, Span<uint> right, ReadOnlySpan<byte> rightValidity)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < right.Length; i++)
             {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (uint)(scalar / span[i]);
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    right[i] = (uint)(left / right[i]);
             }
         }
 
-        public override void Modulo(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+        protected override void Modulo(Span<uint> left, ReadOnlySpan<uint> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (uint)(span[i] % otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (uint)(left[i] % right[i]);
         }
 
-        public override void Modulo(PrimitiveColumnContainer<uint> column, uint scalar)
+        protected override void Modulo(Span<uint> left, uint right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (uint)(span[i] % scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (uint)(left[i] % right);
         }
 
-        public override void Modulo(uint scalar, PrimitiveColumnContainer<uint> column)
+        protected override void Modulo(uint left, Span<uint> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (uint)(scalar % span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (uint)(left % right[i]);
         }
 
-        public override void And(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+        protected override void And(Span<uint> left, ReadOnlySpan<uint> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (uint)(span[i] & otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (uint)(left[i] & right[i]);
         }
 
-        public override void And(PrimitiveColumnContainer<uint> column, uint scalar)
+        protected override void And(Span<uint> left, uint right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (uint)(span[i] & scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (uint)(left[i] & right);
         }
 
-        public override void And(uint scalar, PrimitiveColumnContainer<uint> column)
+        protected override void And(uint left, Span<uint> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (uint)(scalar & span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (uint)(left & right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+        protected override void Or(Span<uint> left, ReadOnlySpan<uint> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (uint)(span[i] | otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (uint)(left[i] | right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<uint> column, uint scalar)
+        protected override void Or(Span<uint> left, uint right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (uint)(span[i] | scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (uint)(left[i] | right);
         }
 
-        public override void Or(uint scalar, PrimitiveColumnContainer<uint> column)
+        protected override void Or(uint left, Span<uint> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (uint)(scalar | span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (uint)(left | right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+        protected override void Xor(Span<uint> left, ReadOnlySpan<uint> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (uint)(span[i] ^ otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (uint)(left[i] ^ right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<uint> column, uint scalar)
+        protected override void Xor(Span<uint> left, uint right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (uint)(span[i] ^ scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (uint)(left[i] ^ right);
         }
 
-        public override void Xor(uint scalar, PrimitiveColumnContainer<uint> column)
+        protected override void Xor(uint left, Span<uint> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (uint)(scalar ^ span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (uint)(left ^ right[i]);
         }
 
-        public override void LeftShift(PrimitiveColumnContainer<uint> column, int value)
+        protected override void LeftShift(Span<uint> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (uint)(span[i] << value);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (uint)(left[i] << right);
         }
 
-        public override void RightShift(PrimitiveColumnContainer<uint> column, int value)
+        protected override void RightShift(Span<uint> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (uint)(span[i] >> value);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (uint)(left[i] >> right);
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+        protected override void ElementwiseEquals(ReadOnlySpan<uint> left, ReadOnlySpan<uint> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == otherSpan[i]);
-                }
+                result[i + offset] = (left[i] == right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<uint> column, uint scalar)
+        protected override void ElementwiseEquals(ReadOnlySpan<uint> left, uint right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == scalar);
-                }
+                result[i + offset] = (left[i] == right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<uint> left, ReadOnlySpan<uint> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != otherSpan[i]);
-                }
+                result[i + offset] = (left[i] != right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<uint> column, uint scalar)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<uint> left, uint right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != scalar);
-                }
+                result[i + offset] = (left[i] != right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<uint> left, ReadOnlySpan<uint> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] >= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<uint> column, uint scalar)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<uint> left, uint right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= scalar);
-                }
+                result[i + offset] = (left[i] >= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<uint> left, ReadOnlySpan<uint> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] <= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<uint> column, uint scalar)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<uint> left, uint right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= scalar);
-                }
+                result[i + offset] = (left[i] <= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<uint> left, ReadOnlySpan<uint> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > otherSpan[i]);
-                }
+                result[i + offset] = (left[i] > right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<uint> column, uint scalar)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<uint> left, uint right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > scalar);
-                }
+                result[i + offset] = (left[i] > right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+        protected override void ElementwiseLessThan(ReadOnlySpan<uint> left, ReadOnlySpan<uint> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < otherSpan[i]);
-                }
+                result[i + offset] = (left[i] < right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<uint> column, uint scalar)
+        protected override void ElementwiseLessThan(ReadOnlySpan<uint> left, uint right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < scalar);
-                }
+                result[i + offset] = (left[i] < right);
             }
-            return ret;
         }
     }
     internal class ULongArithmetic : PrimitiveDataFrameColumnArithmetic<ulong>
     {
 
-        public override void Add(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+        protected override void Add(Span<ulong> left, ReadOnlySpan<ulong> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (ulong)(span[i] + otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ulong)(left[i] + right[i]);
         }
 
-        public override void Add(PrimitiveColumnContainer<ulong> column, ulong scalar)
+        protected override void Add(Span<ulong> left, ulong right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ulong)(span[i] + scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ulong)(left[i] + right);
         }
 
-        public override void Add(ulong scalar, PrimitiveColumnContainer<ulong> column)
+        protected override void Add(ulong left, Span<ulong> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ulong)(scalar + span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (ulong)(left + right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+        protected override void Subtract(Span<ulong> left, ReadOnlySpan<ulong> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (ulong)(span[i] - otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ulong)(left[i] - right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<ulong> column, ulong scalar)
+        protected override void Subtract(Span<ulong> left, ulong right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ulong)(span[i] - scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ulong)(left[i] - right);
         }
 
-        public override void Subtract(ulong scalar, PrimitiveColumnContainer<ulong> column)
+        protected override void Subtract(ulong left, Span<ulong> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ulong)(scalar - span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (ulong)(left - right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+        protected override void Multiply(Span<ulong> left, ReadOnlySpan<ulong> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (ulong)(span[i] * otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ulong)(left[i] * right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<ulong> column, ulong scalar)
+        protected override void Multiply(Span<ulong> left, ulong right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ulong)(span[i] * scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ulong)(left[i] * right);
         }
 
-        public override void Multiply(ulong scalar, PrimitiveColumnContainer<ulong> column)
+        protected override void Multiply(ulong left, Span<ulong> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ulong)(scalar * span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (ulong)(left * right[i]);
         }
 
-        public override void Divide(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+        protected override void Divide(Span<ulong> left, Span<byte> leftValidity, ReadOnlySpan<ulong> right, ReadOnlySpan<byte> rightValidity)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (ulong)(span[i] / otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    left[i] = (ulong)(left[i] / right[i]);
+                else
+                    BitUtility.ClearBit(leftValidity, i);
             }
         }
 
-        public override void Divide(PrimitiveColumnContainer<ulong> column, ulong scalar)
+        protected override void Divide(Span<ulong> left, ulong right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ulong)(span[i] / scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ulong)(left[i] / right);
         }
 
-        public override void Divide(ulong scalar, PrimitiveColumnContainer<ulong> column)
+        protected override void Divide(ulong left, Span<ulong> right, ReadOnlySpan<byte> rightValidity)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < right.Length; i++)
             {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ulong)(scalar / span[i]);
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    right[i] = (ulong)(left / right[i]);
             }
         }
 
-        public override void Modulo(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+        protected override void Modulo(Span<ulong> left, ReadOnlySpan<ulong> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (ulong)(span[i] % otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ulong)(left[i] % right[i]);
         }
 
-        public override void Modulo(PrimitiveColumnContainer<ulong> column, ulong scalar)
+        protected override void Modulo(Span<ulong> left, ulong right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ulong)(span[i] % scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ulong)(left[i] % right);
         }
 
-        public override void Modulo(ulong scalar, PrimitiveColumnContainer<ulong> column)
+        protected override void Modulo(ulong left, Span<ulong> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ulong)(scalar % span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (ulong)(left % right[i]);
         }
 
-        public override void And(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+        protected override void And(Span<ulong> left, ReadOnlySpan<ulong> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (ulong)(span[i] & otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ulong)(left[i] & right[i]);
         }
 
-        public override void And(PrimitiveColumnContainer<ulong> column, ulong scalar)
+        protected override void And(Span<ulong> left, ulong right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ulong)(span[i] & scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ulong)(left[i] & right);
         }
 
-        public override void And(ulong scalar, PrimitiveColumnContainer<ulong> column)
+        protected override void And(ulong left, Span<ulong> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ulong)(scalar & span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (ulong)(left & right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+        protected override void Or(Span<ulong> left, ReadOnlySpan<ulong> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (ulong)(span[i] | otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ulong)(left[i] | right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<ulong> column, ulong scalar)
+        protected override void Or(Span<ulong> left, ulong right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ulong)(span[i] | scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ulong)(left[i] | right);
         }
 
-        public override void Or(ulong scalar, PrimitiveColumnContainer<ulong> column)
+        protected override void Or(ulong left, Span<ulong> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ulong)(scalar | span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (ulong)(left | right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+        protected override void Xor(Span<ulong> left, ReadOnlySpan<ulong> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (ulong)(span[i] ^ otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ulong)(left[i] ^ right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<ulong> column, ulong scalar)
+        protected override void Xor(Span<ulong> left, ulong right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ulong)(span[i] ^ scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ulong)(left[i] ^ right);
         }
 
-        public override void Xor(ulong scalar, PrimitiveColumnContainer<ulong> column)
+        protected override void Xor(ulong left, Span<ulong> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ulong)(scalar ^ span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (ulong)(left ^ right[i]);
         }
 
-        public override void LeftShift(PrimitiveColumnContainer<ulong> column, int value)
+        protected override void LeftShift(Span<ulong> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ulong)(span[i] << value);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ulong)(left[i] << right);
         }
 
-        public override void RightShift(PrimitiveColumnContainer<ulong> column, int value)
+        protected override void RightShift(Span<ulong> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ulong)(span[i] >> value);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ulong)(left[i] >> right);
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+        protected override void ElementwiseEquals(ReadOnlySpan<ulong> left, ReadOnlySpan<ulong> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == otherSpan[i]);
-                }
+                result[i + offset] = (left[i] == right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<ulong> column, ulong scalar)
+        protected override void ElementwiseEquals(ReadOnlySpan<ulong> left, ulong right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == scalar);
-                }
+                result[i + offset] = (left[i] == right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<ulong> left, ReadOnlySpan<ulong> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != otherSpan[i]);
-                }
+                result[i + offset] = (left[i] != right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<ulong> column, ulong scalar)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<ulong> left, ulong right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != scalar);
-                }
+                result[i + offset] = (left[i] != right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<ulong> left, ReadOnlySpan<ulong> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] >= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ulong> column, ulong scalar)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<ulong> left, ulong right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= scalar);
-                }
+                result[i + offset] = (left[i] >= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<ulong> left, ReadOnlySpan<ulong> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] <= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ulong> column, ulong scalar)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<ulong> left, ulong right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= scalar);
-                }
+                result[i + offset] = (left[i] <= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<ulong> left, ReadOnlySpan<ulong> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > otherSpan[i]);
-                }
+                result[i + offset] = (left[i] > right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<ulong> column, ulong scalar)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<ulong> left, ulong right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > scalar);
-                }
+                result[i + offset] = (left[i] > right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+        protected override void ElementwiseLessThan(ReadOnlySpan<ulong> left, ReadOnlySpan<ulong> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < otherSpan[i]);
-                }
+                result[i + offset] = (left[i] < right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<ulong> column, ulong scalar)
+        protected override void ElementwiseLessThan(ReadOnlySpan<ulong> left, ulong right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < scalar);
-                }
+                result[i + offset] = (left[i] < right);
             }
-            return ret;
         }
     }
     internal class UShortArithmetic : PrimitiveDataFrameColumnArithmetic<ushort>
     {
 
-        public override void Add(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+        protected override void Add(Span<ushort> left, ReadOnlySpan<ushort> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (ushort)(span[i] + otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ushort)(left[i] + right[i]);
         }
 
-        public override void Add(PrimitiveColumnContainer<ushort> column, ushort scalar)
+        protected override void Add(Span<ushort> left, ushort right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ushort)(span[i] + scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ushort)(left[i] + right);
         }
 
-        public override void Add(ushort scalar, PrimitiveColumnContainer<ushort> column)
+        protected override void Add(ushort left, Span<ushort> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ushort)(scalar + span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (ushort)(left + right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+        protected override void Subtract(Span<ushort> left, ReadOnlySpan<ushort> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (ushort)(span[i] - otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ushort)(left[i] - right[i]);
         }
 
-        public override void Subtract(PrimitiveColumnContainer<ushort> column, ushort scalar)
+        protected override void Subtract(Span<ushort> left, ushort right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ushort)(span[i] - scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ushort)(left[i] - right);
         }
 
-        public override void Subtract(ushort scalar, PrimitiveColumnContainer<ushort> column)
+        protected override void Subtract(ushort left, Span<ushort> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ushort)(scalar - span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (ushort)(left - right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+        protected override void Multiply(Span<ushort> left, ReadOnlySpan<ushort> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (ushort)(span[i] * otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ushort)(left[i] * right[i]);
         }
 
-        public override void Multiply(PrimitiveColumnContainer<ushort> column, ushort scalar)
+        protected override void Multiply(Span<ushort> left, ushort right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ushort)(span[i] * scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ushort)(left[i] * right);
         }
 
-        public override void Multiply(ushort scalar, PrimitiveColumnContainer<ushort> column)
+        protected override void Multiply(ushort left, Span<ushort> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ushort)(scalar * span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (ushort)(left * right[i]);
         }
 
-        public override void Divide(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+        protected override void Divide(Span<ushort> left, Span<byte> leftValidity, ReadOnlySpan<ushort> right, ReadOnlySpan<byte> rightValidity)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (ushort)(span[i] / otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    left[i] = (ushort)(left[i] / right[i]);
+                else
+                    BitUtility.ClearBit(leftValidity, i);
             }
         }
 
-        public override void Divide(PrimitiveColumnContainer<ushort> column, ushort scalar)
+        protected override void Divide(Span<ushort> left, ushort right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ushort)(span[i] / scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ushort)(left[i] / right);
         }
 
-        public override void Divide(ushort scalar, PrimitiveColumnContainer<ushort> column)
+        protected override void Divide(ushort left, Span<ushort> right, ReadOnlySpan<byte> rightValidity)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < right.Length; i++)
             {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ushort)(scalar / span[i]);
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    right[i] = (ushort)(left / right[i]);
             }
         }
 
-        public override void Modulo(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+        protected override void Modulo(Span<ushort> left, ReadOnlySpan<ushort> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (ushort)(span[i] % otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ushort)(left[i] % right[i]);
         }
 
-        public override void Modulo(PrimitiveColumnContainer<ushort> column, ushort scalar)
+        protected override void Modulo(Span<ushort> left, ushort right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ushort)(span[i] % scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ushort)(left[i] % right);
         }
 
-        public override void Modulo(ushort scalar, PrimitiveColumnContainer<ushort> column)
+        protected override void Modulo(ushort left, Span<ushort> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ushort)(scalar % span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (ushort)(left % right[i]);
         }
 
-        public override void And(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+        protected override void And(Span<ushort> left, ReadOnlySpan<ushort> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (ushort)(span[i] & otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ushort)(left[i] & right[i]);
         }
 
-        public override void And(PrimitiveColumnContainer<ushort> column, ushort scalar)
+        protected override void And(Span<ushort> left, ushort right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ushort)(span[i] & scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ushort)(left[i] & right);
         }
 
-        public override void And(ushort scalar, PrimitiveColumnContainer<ushort> column)
+        protected override void And(ushort left, Span<ushort> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ushort)(scalar & span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (ushort)(left & right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+        protected override void Or(Span<ushort> left, ReadOnlySpan<ushort> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (ushort)(span[i] | otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ushort)(left[i] | right[i]);
         }
 
-        public override void Or(PrimitiveColumnContainer<ushort> column, ushort scalar)
+        protected override void Or(Span<ushort> left, ushort right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ushort)(span[i] | scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ushort)(left[i] | right);
         }
 
-        public override void Or(ushort scalar, PrimitiveColumnContainer<ushort> column)
+        protected override void Or(ushort left, Span<ushort> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ushort)(scalar | span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (ushort)(left | right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+        protected override void Xor(Span<ushort> left, ReadOnlySpan<ushort> right)
         {
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
-            {
-                var mutableBuffer = left.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (ushort)(span[i] ^ otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ushort)(left[i] ^ right[i]);
         }
 
-        public override void Xor(PrimitiveColumnContainer<ushort> column, ushort scalar)
+        protected override void Xor(Span<ushort> left, ushort right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ushort)(span[i] ^ scalar);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ushort)(left[i] ^ right);
         }
 
-        public override void Xor(ushort scalar, PrimitiveColumnContainer<ushort> column)
+        protected override void Xor(ushort left, Span<ushort> right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ushort)(scalar ^ span[i]);
-                }
-            }
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (ushort)(left ^ right[i]);
         }
 
-        public override void LeftShift(PrimitiveColumnContainer<ushort> column, int value)
+        protected override void LeftShift(Span<ushort> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ushort)(span[i] << value);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ushort)(left[i] << right);
         }
 
-        public override void RightShift(PrimitiveColumnContainer<ushort> column, int value)
+        protected override void RightShift(Span<ushort> left, int right)
         {
-            for (int b = 0; b < column.Buffers.Count; b++)
-            {
-                var mutableBuffer = column.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    span[i] = (ushort)(span[i] >> value);
-                }
-            }
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (ushort)(left[i] >> right);
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+        protected override void ElementwiseEquals(ReadOnlySpan<ushort> left, ReadOnlySpan<ushort> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == otherSpan[i]);
-                }
+                result[i + offset] = (left[i] == right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<ushort> column, ushort scalar)
+        protected override void ElementwiseEquals(ReadOnlySpan<ushort> left, ushort right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == scalar);
-                }
+                result[i + offset] = (left[i] == right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<ushort> left, ReadOnlySpan<ushort> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != otherSpan[i]);
-                }
+                result[i + offset] = (left[i] != right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<ushort> column, ushort scalar)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<ushort> left, ushort right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != scalar);
-                }
+                result[i + offset] = (left[i] != right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<ushort> left, ReadOnlySpan<ushort> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] >= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ushort> column, ushort scalar)
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<ushort> left, ushort right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] >= scalar);
-                }
+                result[i + offset] = (left[i] >= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<ushort> left, ReadOnlySpan<ushort> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= otherSpan[i]);
-                }
+                result[i + offset] = (left[i] <= right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ushort> column, ushort scalar)
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<ushort> left, ushort right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] <= scalar);
-                }
+                result[i + offset] = (left[i] <= right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<ushort> left, ReadOnlySpan<ushort> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > otherSpan[i]);
-                }
+                result[i + offset] = (left[i] > right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<ushort> column, ushort scalar)
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<ushort> left, ushort right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] > scalar);
-                }
+                result[i + offset] = (left[i] > right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+        protected override void ElementwiseLessThan(ReadOnlySpan<ushort> left, ReadOnlySpan<ushort> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < otherSpan[i]);
-                }
+                result[i + offset] = (left[i] < right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<ushort> column, ushort scalar)
+        protected override void ElementwiseLessThan(ReadOnlySpan<ushort> left, ushort right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] < scalar);
-                }
+                result[i + offset] = (left[i] < right);
             }
-            return ret;
         }
     }
     internal class DateTimeArithmetic : PrimitiveDataFrameColumnArithmetic<DateTime>
     {
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
+        protected override void ElementwiseEquals(ReadOnlySpan<DateTime> left, ReadOnlySpan<DateTime> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == otherSpan[i]);
-                }
+                result[i + offset] = (left[i] == right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
+        protected override void ElementwiseEquals(ReadOnlySpan<DateTime> left, DateTime right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] == scalar);
-                }
+                result[i + offset] = (left[i] == right);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<DateTime> left, ReadOnlySpan<DateTime> right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-            for (int b = 0; b < left.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = left.Buffers[b].ReadOnlySpan;
-                var otherSpan = right.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != otherSpan[i]);
-                }
+                result[i + offset] = (left[i] != right[i]);
             }
-            return ret;
         }
 
-        public override PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
+        protected override void ElementwiseNotEquals(ReadOnlySpan<DateTime> left, DateTime right, PrimitiveColumnContainer<bool> result, long offset)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-            for (int b = 0; b < column.Buffers.Count; b++)
+            for (var i = 0; i < left.Length; i++)
             {
-                var span = column.Buffers[b].ReadOnlySpan;
-                for (int i = 0; i < span.Length; i++)
-                {
-                    ret[index++] = (span[i] != scalar);
-                }
+                result[i + offset] = (left[i] != right);
             }
-            return ret;
         }
     }
 }
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt
index cdc4e02578..ec1478b66b 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt
@@ -6,7 +6,6 @@
 <#@ import namespace="System.Collections.Generic" #>
 <#@ output extension=".cs" #>
 <#@ include file="ColumnArithmeticTemplate.ttinclude" #>
-
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
@@ -17,50 +16,125 @@ using System;
 
 namespace Microsoft.Data.Analysis
 {
-    internal interface IPrimitiveDataFrameColumnArithmetic<T>
+    internal class PrimitiveDataFrameColumnArithmetic<T> : IPrimitiveDataFrameColumnArithmetic<T>
         where T : unmanaged
     {
+        public static IPrimitiveDataFrameColumnArithmetic<T> Instance { get; } = PrimitiveDataFrameColumnArithmetic.GetArithmetic<T>();
+
+        public void HandleOperation(BinaryOperation operation, Span<T> left, Span<byte> leftValidity, ReadOnlySpan<T> right, ReadOnlySpan<byte> rightValidity)
+        {
+            if (operation == BinaryOperation.Divide)
+            {
+                Divide(left, leftValidity, right, rightValidity);
+                return;
+            }
 <# foreach (MethodConfiguration method in methodConfiguration) { #>
-<# if (method.MethodType == MethodType.Comparison) { #>
-        PrimitiveColumnContainer<bool> <#=method.MethodName#>(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
+<# if (method.MethodType == MethodType.Binary) { #>
+<# if (method.MethodName != "Divide") { #>
+            else if (operation == BinaryOperation.<#=method.MethodName#>)
+                <#=method.MethodName#>(left, right);
 <# } #>
-<# else if (method.MethodType == MethodType.ComparisonScalar) { #>
-        PrimitiveColumnContainer<bool> <#=method.MethodName#>(PrimitiveColumnContainer<T> column, T scalar);
 <# } #>
-<# else if (method.MethodType == MethodType.Binary) { #>
-        void <#=method.MethodName#>(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
 <# } #>
-<# else if (method.MethodType == MethodType.BinaryScalar) { #>
-        void <#=method.MethodName#>(PrimitiveColumnContainer<T> column, T scalar);
-        void <#=method.MethodName#>(T scalar, PrimitiveColumnContainer<T> column);
+
+            BitUtility.ElementwiseAnd(leftValidity, rightValidity, leftValidity);
+        }
+
+        public void HandleOperation(BinaryScalarOperation operation, Span<T> left, T right)
+        {
+            switch (operation)
+            {
+<# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (method.MethodType == MethodType.BinaryScalar) { #>
+                case BinaryScalarOperation.<#=method.MethodName#>:
+                    <#=method.MethodName#>(left, right);
+                    break;
 <# } #>
-<# else if (method.MethodType == MethodType.BinaryInt) { #>
-        void <#=method.MethodName#>(PrimitiveColumnContainer<T> column, int value);
 <# } #>
+            }
+        }
+
+        public void HandleOperation(BinaryScalarOperation operation, T left, Span<T> right, ReadOnlySpan<byte> rightValidity)
+        {
+            if (operation == BinaryScalarOperation.Divide)
+            {
+                Divide(left, right, rightValidity);
+                return;
+            }
+<# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (method.MethodType == MethodType.BinaryScalar) { #>
+<# if (method.MethodName != "Divide") { #>
+            else if (operation == BinaryScalarOperation.<#=method.MethodName#>)
+                <#=method.MethodName#>(left, right);
 <# } #>
-    }
+<# } #>
+<# } #>
+        }
 
-    internal class PrimitiveDataFrameColumnArithmetic<T> : IPrimitiveDataFrameColumnArithmetic<T>
-        where T : unmanaged
-    {
-        public static IPrimitiveDataFrameColumnArithmetic<T> Instance { get; } = PrimitiveDataFrameColumnArithmetic.GetArithmetic<T>();
+        public void HandleOperation(BinaryIntOperation operation, Span<T> left, int right)
+        {
+            switch (operation)
+            {
+<# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (method.MethodType == MethodType.BinaryInt) { #>
+                case BinaryIntOperation.<#=method.MethodName#>:
+                    <#=method.MethodName#>(left, right);
+                    break;
+<# } #>
+<# } #>
+            }
+        }
+
+        public void HandleOperation(ComparisonOperation operation, ReadOnlySpan<T> left, ReadOnlySpan<T> right, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            switch (operation)
+            {
+<# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (method.MethodType == MethodType.Comparison) { #>
+                case ComparisonOperation.<#=method.MethodName#>:
+                    <#=method.MethodName#>(left, right, result, offset);
+                    break;
+<# } #>
+<# } #>
+            }
+        }
+
+        public void HandleOperation(ComparisonScalarOperation operation, ReadOnlySpan<T> left, T right, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            switch (operation)
+            {
+<# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (method.MethodType == MethodType.ComparisonScalar) { #>
+                case ComparisonScalarOperation.<#=method.MethodName#>:
+                    <#=method.MethodName#>(left, right, result, offset);
+                    break;
+<# } #>
+<# } #>
+            }
+        }
 
 <# foreach (MethodConfiguration method in methodConfiguration) { #>
 <# if (method.MethodType == MethodType.Comparison) { #>
-        public virtual PrimitiveColumnContainer<bool> <#=method.MethodName#>(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right) => throw new NotSupportedException();
+        protected virtual void <#=method.MethodName#>(ReadOnlySpan<T> left, ReadOnlySpan<T> right, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
 <# } #>
 <# else if (method.MethodType == MethodType.ComparisonScalar) { #>
-        public virtual PrimitiveColumnContainer<bool> <#=method.MethodName#>(PrimitiveColumnContainer<T> column, T scalar) => throw new NotSupportedException();
+        protected virtual void <#=method.MethodName#>(ReadOnlySpan<T> left, T right, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
 <# } #>
 <# else if (method.MethodType == MethodType.Binary) { #>
-        public virtual void <#=method.MethodName#>(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right) => throw new NotSupportedException();
+<# if (method.MethodName == "Divide") { #>
+        protected virtual void <#=method.MethodName#>(Span<T> left, Span<byte> leftValidity, ReadOnlySpan<T> right, ReadOnlySpan<byte> rightValidity) => throw new NotSupportedException();
+<# } else {#>
+        protected virtual void <#=method.MethodName#>(Span<T> left, ReadOnlySpan<T> right) => throw new NotSupportedException();
 <# } #>
-<# else if (method.MethodType == MethodType.BinaryScalar) { #>
-        public virtual void <#=method.MethodName#>(PrimitiveColumnContainer<T> column, T scalar) => throw new NotSupportedException();
-        public virtual void <#=method.MethodName#>(T scalar, PrimitiveColumnContainer<T> column) => throw new NotSupportedException();
+<# } else if (method.MethodType == MethodType.BinaryScalar) { #>
+        protected virtual void <#=method.MethodName#>(Span<T> left, T scalar) => throw new NotSupportedException();
+<# if (method.MethodName == "Divide") { #>
+        protected virtual void <#=method.MethodName#>(T left, Span<T> right, ReadOnlySpan<byte> rightValidity) => throw new NotSupportedException();
+<# } else { #>
+        protected virtual void <#=method.MethodName#>(T left, Span<T> right) => throw new NotSupportedException();
 <# } #>
-<# else if (method.MethodType == MethodType.BinaryInt) { #>
-        public virtual void <#=method.MethodName#>(PrimitiveColumnContainer<T> column, int value) => throw new NotSupportedException();
+<# } else if (method.MethodType == MethodType.BinaryInt) { #>
+        protected virtual void <#=method.MethodName#>(Span<T> left, int right) => throw new NotSupportedException();
 <# } #>
 <# } #>
 
@@ -73,13 +147,12 @@ namespace Microsoft.Data.Analysis
         {
 <# foreach (TypeConfiguration type in typeConfiguration) { #>
             <#=GenerateIfStatementHeader(type)#>
-            {
                 return (IPrimitiveDataFrameColumnArithmetic<T>)new <#=type.ClassPrefix#>Arithmetic();
-            }
 <# } #>
             throw new NotSupportedException();
         }
     }
+
 <# foreach (TypeConfiguration type in typeConfiguration) { #>
     internal class <#=type.ClassPrefix#>Arithmetic : PrimitiveDataFrameColumnArithmetic<<#=type.TypeName#>>
     {
@@ -87,96 +160,77 @@ namespace Microsoft.Data.Analysis
 <# if (!((method.IsNumeric && !type.SupportsNumeric) || (method.IsBitwise && !type.SupportsBitwise) || (type.UnsupportedMethods.Contains(method.MethodName))) && method.Operator != null) { #>
 <# if (method.MethodType == MethodType.Comparison) { #>
 
-        public override PrimitiveColumnContainer<bool> <#=method.MethodName#>(PrimitiveColumnContainer<<#=type.TypeName#>> left, PrimitiveColumnContainer<<#=type.TypeName#>> right)
-<# } #>
-<# else if (method.MethodType == MethodType.ComparisonScalar) { #>
+        protected override void <#=method.MethodName#>(ReadOnlySpan<<#=type.TypeName#>> left, ReadOnlySpan<<#=type.TypeName#>> right, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < left.Length; i++)
+            {
+                result[i + offset] = (left[i] <#= method.Operator #> right[i]);
+            }
+        }
+<# } else if (method.MethodType == MethodType.ComparisonScalar) {#>
 
-        public override PrimitiveColumnContainer<bool> <#=method.MethodName#>(PrimitiveColumnContainer<<#=type.TypeName#>> column, <#=type.TypeName#> scalar)
-<# } #>
-<# else if (method.MethodType == MethodType.Binary) { #>
+        protected override void <#=method.MethodName#>(ReadOnlySpan<<#=type.TypeName#>> left, <#=type.TypeName#> right, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < left.Length; i++)
+            {
+                result[i + offset] = (left[i] <#= method.Operator #> right);
+            }
+        }
+<# } else if (method.MethodType == MethodType.Binary) { #>
+<# if (method.MethodName == "Divide") { #>
 
-        public override void <#=method.MethodName#>(PrimitiveColumnContainer<<#=type.TypeName#>> left, PrimitiveColumnContainer<<#=type.TypeName#>> right)
+        protected override void <#=method.MethodName#>(Span<<#=type.TypeName#>> left, Span<byte> leftValidity, ReadOnlySpan<<#=type.TypeName#>> right, ReadOnlySpan<byte> rightValidity)
+        {
+            for (var i = 0; i < left.Length; i++)
+            {
+                if (BitUtility.IsValid(rightValidity, i))
+                    left[i] = (<#=type.TypeName#>)(left[i] <#= method.Operator #> right[i]);
+                else
+                    BitUtility.ClearBit(leftValidity, i);
+            }
+        }
+<# } else { #>
+
+        protected override void <#=method.MethodName#>(Span<<#=type.TypeName#>> left, ReadOnlySpan<<#=type.TypeName#>> right)
+        {
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (<#=type.TypeName#>)(left[i] <#= method.Operator #> right[i]);
+        }
+<# } #>
 <# } #>
 <# else if (method.MethodType == MethodType.BinaryScalar) { #>
 
-        public override void <#=method.MethodName#>(PrimitiveColumnContainer<<#=type.TypeName#>> column, <#=type.TypeName#> scalar)
-<# } #>
-<# else if (method.MethodType == MethodType.BinaryInt) { #>
+        protected override void <#=method.MethodName#>(Span<<#=type.TypeName#>> left, <#=type.TypeName#> right)
+        {
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (<#=type.TypeName#>)(left[i] <#= method.Operator #> right);
+        }
+<# if (method.MethodName == "Divide") { #>
 
-        public override void <#=method.MethodName#>(PrimitiveColumnContainer<<#=type.TypeName#>> column, int value)
-<# } #>
+        protected override void <#=method.MethodName#>(<#=type.TypeName#> left, Span<<#=type.TypeName#>> right, ReadOnlySpan<byte> rightValidity)
         {
-<# if (method.MethodType == MethodType.Binary) { #>
-            long index = 0;
-<# } #>
-<# if (method.MethodType == MethodType.Comparison) { #>
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
-            long index = 0;
-<# } #>
-<# if (method.MethodType == MethodType.ComparisonScalar) { #>
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
-            long index = 0;
-<# } #>
-            for (int b = 0; b < <#= method.Op1Name #>.Buffers.Count; b++)
+            for (var i = 0; i < right.Length; i++)
             {
-<# if (method.MethodType == MethodType.Comparison) { #>
-                var span = <#= method.Op1Name #>.Buffers[b].ReadOnlySpan;
-                var otherSpan = <#=method.Op2Name#>.Buffers[b].ReadOnlySpan;
-<# } else if (method.MethodType == MethodType.ComparisonScalar){#>
-                var span = <#= method.Op1Name #>.Buffers[b].ReadOnlySpan;
-<# } else {#>
-                var mutableBuffer = <#= method.Op1Name #>.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-<# if (method.MethodType == MethodType.Binary) { #>
-                var otherSpan = <#=method.Op2Name#>.Buffers[b].ReadOnlySpan;
-<# } #>
-<# } #>
-                for (int i = 0; i < span.Length; i++)
-                {
-<# if (method.MethodType == MethodType.BinaryScalar || method.MethodType == MethodType.BinaryInt) { #>
-                    span[i] = (<#=type.TypeName#>)(span[i] <#= method.Operator #> <#= method.Op2Name #>);
-<# } else if (method.MethodType == MethodType.Binary) { #>
-                    if (BitmapHelper.IsValid(right.NullBitMapBuffers[b].ReadOnlySpan, i))
-                    {
-                        span[i] = (<#=type.TypeName#>)(span[i] <#= method.Operator #> otherSpan[i]);
-                    }
-                    else
-                    {
-                        left[index] = null;
-                    }
-
-                    index++;
-<# } else if (method.MethodType == MethodType.Comparison) { #>
-                    ret[index++] = (span[i] <#= method.Operator #> otherSpan[i]);
-<# } else if (method.MethodType == MethodType.ComparisonScalar) { #>
-                    ret[index++] = (span[i] <#= method.Operator #> <#= method.Op2Name #>);
-<# } else {#>
-                    throw new NotImplementedException();
-<# } #>
-                }
+                if (BitUtility.IsValid(rightValidity, i))
+                    right[i] = (<#=type.TypeName#>)(left <#= method.Operator #> right[i]);
             }
-<# if (method.MethodType == MethodType.Comparison || method.MethodType == MethodType.ComparisonScalar) { #>
-            return ret;
-<# } #>
         }
-<# if (method.MethodType == MethodType.BinaryScalar) { #>
+<# } #>
+<# else { #>
 
-        public override <#= method.GetInvertedMethodSignatureForBinaryScalarsOps("PrimitiveColumnContainer", type.TypeName) #>
+        protected override void <#=method.MethodName#>(<#=type.TypeName#> left, Span<<#=type.TypeName#>> right)
         {
-            for (int b = 0; b < <#= method.Op1Name #>.Buffers.Count; b++)
-            {
-                var mutableBuffer = <#= method.Op1Name #>.Buffers.GetOrCreateMutable(b);
-                var span = mutableBuffer.Span;
-<# if (method.MethodType == MethodType.Binary || method.MethodType == MethodType.Comparison) { #>
-                var otherSpan = <#=method.Op2Name#>.Buffers[b].ReadOnlySpan;
+            for (var i = 0; i < right.Length; i++)
+                right[i] = (<#=type.TypeName#>)(left <#= method.Operator #> right[i]);
+        }
 <# } #>
-                for (int i = 0; i < span.Length; i++)
-                {
-<# if (method.MethodType == MethodType.BinaryScalar || method.MethodType == MethodType.BinaryInt) { #>
-                    span[i] = (<#=type.TypeName#>)(<#= method.Op2Name #> <#= method.Operator #> span[i]);
 <# } #>
-                }
-            }
+<# else if (method.MethodType == MethodType.BinaryInt) { #>
+
+        protected override void <#=method.MethodName#>(Span<<#=type.TypeName#>> left, int right)
+        {
+            for (var i = 0; i < left.Length; i++)
+                left[i] = (<#=type.TypeName#>)(left[i] <#= method.Operator #> right);
         }
 <# } #>
 <# } #>
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.cs
index cf01656497..b7523f5213 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.cs
@@ -281,7 +281,7 @@ public void CumulativeMax(PrimitiveColumnContainer<byte> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (byte)(Math.Max(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -345,7 +345,7 @@ public void CumulativeMin(PrimitiveColumnContainer<byte> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (byte)(Math.Min(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -409,7 +409,7 @@ public void CumulativeProduct(PrimitiveColumnContainer<byte> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (byte)(readOnlySpan[i] * ret);
                         mutableSpan[i] = ret;
@@ -473,7 +473,7 @@ public void CumulativeSum(PrimitiveColumnContainer<byte> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (byte)(readOnlySpan[i] + ret);
                         mutableSpan[i] = ret;
@@ -536,7 +536,7 @@ public void Max(PrimitiveColumnContainer<byte> column, out byte? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (byte)(Math.Max(readOnlySpan[i], value));
@@ -584,7 +584,7 @@ public void Min(PrimitiveColumnContainer<byte> column, out byte? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (byte)(Math.Min(readOnlySpan[i], value));
@@ -631,7 +631,7 @@ public void Product(PrimitiveColumnContainer<byte> column, out byte? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (byte)(readOnlySpan[i] * ret);
                     }
@@ -676,7 +676,7 @@ public void Sum(PrimitiveColumnContainer<byte> column, out byte? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (byte)(readOnlySpan[i] + value);
@@ -768,7 +768,7 @@ public void CumulativeMax(PrimitiveColumnContainer<char> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (char)(Math.Max(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -832,7 +832,7 @@ public void CumulativeMin(PrimitiveColumnContainer<char> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (char)(Math.Min(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -896,7 +896,7 @@ public void CumulativeProduct(PrimitiveColumnContainer<char> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (char)(readOnlySpan[i] * ret);
                         mutableSpan[i] = ret;
@@ -960,7 +960,7 @@ public void CumulativeSum(PrimitiveColumnContainer<char> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (char)(readOnlySpan[i] + ret);
                         mutableSpan[i] = ret;
@@ -1023,7 +1023,7 @@ public void Max(PrimitiveColumnContainer<char> column, out char? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (char)(Math.Max(readOnlySpan[i], value));
@@ -1071,7 +1071,7 @@ public void Min(PrimitiveColumnContainer<char> column, out char? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (char)(Math.Min(readOnlySpan[i], value));
@@ -1118,7 +1118,7 @@ public void Product(PrimitiveColumnContainer<char> column, out char? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (char)(readOnlySpan[i] * ret);
                     }
@@ -1163,7 +1163,7 @@ public void Sum(PrimitiveColumnContainer<char> column, out char? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (char)(readOnlySpan[i] + value);
@@ -1255,7 +1255,7 @@ public void CumulativeMax(PrimitiveColumnContainer<decimal> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (decimal)(Math.Max(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -1319,7 +1319,7 @@ public void CumulativeMin(PrimitiveColumnContainer<decimal> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (decimal)(Math.Min(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -1383,7 +1383,7 @@ public void CumulativeProduct(PrimitiveColumnContainer<decimal> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (decimal)(readOnlySpan[i] * ret);
                         mutableSpan[i] = ret;
@@ -1447,7 +1447,7 @@ public void CumulativeSum(PrimitiveColumnContainer<decimal> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (decimal)(readOnlySpan[i] + ret);
                         mutableSpan[i] = ret;
@@ -1510,7 +1510,7 @@ public void Max(PrimitiveColumnContainer<decimal> column, out decimal? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (decimal)(Math.Max(readOnlySpan[i], value));
@@ -1558,7 +1558,7 @@ public void Min(PrimitiveColumnContainer<decimal> column, out decimal? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (decimal)(Math.Min(readOnlySpan[i], value));
@@ -1605,7 +1605,7 @@ public void Product(PrimitiveColumnContainer<decimal> column, out decimal? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (decimal)(readOnlySpan[i] * ret);
                     }
@@ -1650,7 +1650,7 @@ public void Sum(PrimitiveColumnContainer<decimal> column, out decimal? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (decimal)(readOnlySpan[i] + value);
@@ -1742,7 +1742,7 @@ public void CumulativeMax(PrimitiveColumnContainer<double> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (double)(Math.Max(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -1806,7 +1806,7 @@ public void CumulativeMin(PrimitiveColumnContainer<double> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (double)(Math.Min(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -1870,7 +1870,7 @@ public void CumulativeProduct(PrimitiveColumnContainer<double> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (double)(readOnlySpan[i] * ret);
                         mutableSpan[i] = ret;
@@ -1934,7 +1934,7 @@ public void CumulativeSum(PrimitiveColumnContainer<double> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (double)(readOnlySpan[i] + ret);
                         mutableSpan[i] = ret;
@@ -1997,7 +1997,7 @@ public void Max(PrimitiveColumnContainer<double> column, out double? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (double)(Math.Max(readOnlySpan[i], value));
@@ -2045,7 +2045,7 @@ public void Min(PrimitiveColumnContainer<double> column, out double? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (double)(Math.Min(readOnlySpan[i], value));
@@ -2092,7 +2092,7 @@ public void Product(PrimitiveColumnContainer<double> column, out double? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (double)(readOnlySpan[i] * ret);
                     }
@@ -2137,7 +2137,7 @@ public void Sum(PrimitiveColumnContainer<double> column, out double? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (double)(readOnlySpan[i] + value);
@@ -2229,7 +2229,7 @@ public void CumulativeMax(PrimitiveColumnContainer<float> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (float)(Math.Max(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -2293,7 +2293,7 @@ public void CumulativeMin(PrimitiveColumnContainer<float> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (float)(Math.Min(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -2357,7 +2357,7 @@ public void CumulativeProduct(PrimitiveColumnContainer<float> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (float)(readOnlySpan[i] * ret);
                         mutableSpan[i] = ret;
@@ -2421,7 +2421,7 @@ public void CumulativeSum(PrimitiveColumnContainer<float> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (float)(readOnlySpan[i] + ret);
                         mutableSpan[i] = ret;
@@ -2484,7 +2484,7 @@ public void Max(PrimitiveColumnContainer<float> column, out float? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (float)(Math.Max(readOnlySpan[i], value));
@@ -2532,7 +2532,7 @@ public void Min(PrimitiveColumnContainer<float> column, out float? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (float)(Math.Min(readOnlySpan[i], value));
@@ -2579,7 +2579,7 @@ public void Product(PrimitiveColumnContainer<float> column, out float? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (float)(readOnlySpan[i] * ret);
                     }
@@ -2624,7 +2624,7 @@ public void Sum(PrimitiveColumnContainer<float> column, out float? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (float)(readOnlySpan[i] + value);
@@ -2716,7 +2716,7 @@ public void CumulativeMax(PrimitiveColumnContainer<int> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (int)(Math.Max(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -2780,7 +2780,7 @@ public void CumulativeMin(PrimitiveColumnContainer<int> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (int)(Math.Min(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -2844,7 +2844,7 @@ public void CumulativeProduct(PrimitiveColumnContainer<int> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (int)(readOnlySpan[i] * ret);
                         mutableSpan[i] = ret;
@@ -2908,7 +2908,7 @@ public void CumulativeSum(PrimitiveColumnContainer<int> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (int)(readOnlySpan[i] + ret);
                         mutableSpan[i] = ret;
@@ -2971,7 +2971,7 @@ public void Max(PrimitiveColumnContainer<int> column, out int? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (int)(Math.Max(readOnlySpan[i], value));
@@ -3019,7 +3019,7 @@ public void Min(PrimitiveColumnContainer<int> column, out int? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (int)(Math.Min(readOnlySpan[i], value));
@@ -3066,7 +3066,7 @@ public void Product(PrimitiveColumnContainer<int> column, out int? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (int)(readOnlySpan[i] * ret);
                     }
@@ -3111,7 +3111,7 @@ public void Sum(PrimitiveColumnContainer<int> column, out int? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (int)(readOnlySpan[i] + value);
@@ -3203,7 +3203,7 @@ public void CumulativeMax(PrimitiveColumnContainer<long> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (long)(Math.Max(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -3267,7 +3267,7 @@ public void CumulativeMin(PrimitiveColumnContainer<long> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (long)(Math.Min(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -3331,7 +3331,7 @@ public void CumulativeProduct(PrimitiveColumnContainer<long> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (long)(readOnlySpan[i] * ret);
                         mutableSpan[i] = ret;
@@ -3395,7 +3395,7 @@ public void CumulativeSum(PrimitiveColumnContainer<long> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (long)(readOnlySpan[i] + ret);
                         mutableSpan[i] = ret;
@@ -3458,7 +3458,7 @@ public void Max(PrimitiveColumnContainer<long> column, out long? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (long)(Math.Max(readOnlySpan[i], value));
@@ -3506,7 +3506,7 @@ public void Min(PrimitiveColumnContainer<long> column, out long? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (long)(Math.Min(readOnlySpan[i], value));
@@ -3553,7 +3553,7 @@ public void Product(PrimitiveColumnContainer<long> column, out long? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (long)(readOnlySpan[i] * ret);
                     }
@@ -3598,7 +3598,7 @@ public void Sum(PrimitiveColumnContainer<long> column, out long? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (long)(readOnlySpan[i] + value);
@@ -3690,7 +3690,7 @@ public void CumulativeMax(PrimitiveColumnContainer<sbyte> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (sbyte)(Math.Max(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -3754,7 +3754,7 @@ public void CumulativeMin(PrimitiveColumnContainer<sbyte> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (sbyte)(Math.Min(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -3818,7 +3818,7 @@ public void CumulativeProduct(PrimitiveColumnContainer<sbyte> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (sbyte)(readOnlySpan[i] * ret);
                         mutableSpan[i] = ret;
@@ -3882,7 +3882,7 @@ public void CumulativeSum(PrimitiveColumnContainer<sbyte> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (sbyte)(readOnlySpan[i] + ret);
                         mutableSpan[i] = ret;
@@ -3945,7 +3945,7 @@ public void Max(PrimitiveColumnContainer<sbyte> column, out sbyte? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (sbyte)(Math.Max(readOnlySpan[i], value));
@@ -3993,7 +3993,7 @@ public void Min(PrimitiveColumnContainer<sbyte> column, out sbyte? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (sbyte)(Math.Min(readOnlySpan[i], value));
@@ -4040,7 +4040,7 @@ public void Product(PrimitiveColumnContainer<sbyte> column, out sbyte? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (sbyte)(readOnlySpan[i] * ret);
                     }
@@ -4085,7 +4085,7 @@ public void Sum(PrimitiveColumnContainer<sbyte> column, out sbyte? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (sbyte)(readOnlySpan[i] + value);
@@ -4177,7 +4177,7 @@ public void CumulativeMax(PrimitiveColumnContainer<short> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (short)(Math.Max(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -4241,7 +4241,7 @@ public void CumulativeMin(PrimitiveColumnContainer<short> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (short)(Math.Min(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -4305,7 +4305,7 @@ public void CumulativeProduct(PrimitiveColumnContainer<short> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (short)(readOnlySpan[i] * ret);
                         mutableSpan[i] = ret;
@@ -4369,7 +4369,7 @@ public void CumulativeSum(PrimitiveColumnContainer<short> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (short)(readOnlySpan[i] + ret);
                         mutableSpan[i] = ret;
@@ -4432,7 +4432,7 @@ public void Max(PrimitiveColumnContainer<short> column, out short? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (short)(Math.Max(readOnlySpan[i], value));
@@ -4480,7 +4480,7 @@ public void Min(PrimitiveColumnContainer<short> column, out short? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (short)(Math.Min(readOnlySpan[i], value));
@@ -4527,7 +4527,7 @@ public void Product(PrimitiveColumnContainer<short> column, out short? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (short)(readOnlySpan[i] * ret);
                     }
@@ -4572,7 +4572,7 @@ public void Sum(PrimitiveColumnContainer<short> column, out short? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (short)(readOnlySpan[i] + value);
@@ -4664,7 +4664,7 @@ public void CumulativeMax(PrimitiveColumnContainer<uint> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (uint)(Math.Max(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -4728,7 +4728,7 @@ public void CumulativeMin(PrimitiveColumnContainer<uint> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (uint)(Math.Min(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -4792,7 +4792,7 @@ public void CumulativeProduct(PrimitiveColumnContainer<uint> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (uint)(readOnlySpan[i] * ret);
                         mutableSpan[i] = ret;
@@ -4856,7 +4856,7 @@ public void CumulativeSum(PrimitiveColumnContainer<uint> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (uint)(readOnlySpan[i] + ret);
                         mutableSpan[i] = ret;
@@ -4919,7 +4919,7 @@ public void Max(PrimitiveColumnContainer<uint> column, out uint? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (uint)(Math.Max(readOnlySpan[i], value));
@@ -4967,7 +4967,7 @@ public void Min(PrimitiveColumnContainer<uint> column, out uint? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (uint)(Math.Min(readOnlySpan[i], value));
@@ -5014,7 +5014,7 @@ public void Product(PrimitiveColumnContainer<uint> column, out uint? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (uint)(readOnlySpan[i] * ret);
                     }
@@ -5059,7 +5059,7 @@ public void Sum(PrimitiveColumnContainer<uint> column, out uint? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (uint)(readOnlySpan[i] + value);
@@ -5151,7 +5151,7 @@ public void CumulativeMax(PrimitiveColumnContainer<ulong> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (ulong)(Math.Max(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -5215,7 +5215,7 @@ public void CumulativeMin(PrimitiveColumnContainer<ulong> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (ulong)(Math.Min(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -5279,7 +5279,7 @@ public void CumulativeProduct(PrimitiveColumnContainer<ulong> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (ulong)(readOnlySpan[i] * ret);
                         mutableSpan[i] = ret;
@@ -5343,7 +5343,7 @@ public void CumulativeSum(PrimitiveColumnContainer<ulong> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (ulong)(readOnlySpan[i] + ret);
                         mutableSpan[i] = ret;
@@ -5406,7 +5406,7 @@ public void Max(PrimitiveColumnContainer<ulong> column, out ulong? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (ulong)(Math.Max(readOnlySpan[i], value));
@@ -5454,7 +5454,7 @@ public void Min(PrimitiveColumnContainer<ulong> column, out ulong? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (ulong)(Math.Min(readOnlySpan[i], value));
@@ -5501,7 +5501,7 @@ public void Product(PrimitiveColumnContainer<ulong> column, out ulong? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (ulong)(readOnlySpan[i] * ret);
                     }
@@ -5546,7 +5546,7 @@ public void Sum(PrimitiveColumnContainer<ulong> column, out ulong? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (ulong)(readOnlySpan[i] + value);
@@ -5638,7 +5638,7 @@ public void CumulativeMax(PrimitiveColumnContainer<ushort> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (ushort)(Math.Max(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -5702,7 +5702,7 @@ public void CumulativeMin(PrimitiveColumnContainer<ushort> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (ushort)(Math.Min(readOnlySpan[i], ret));
                         mutableSpan[i] = ret;
@@ -5766,7 +5766,7 @@ public void CumulativeProduct(PrimitiveColumnContainer<ushort> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (ushort)(readOnlySpan[i] * ret);
                         mutableSpan[i] = ret;
@@ -5830,7 +5830,7 @@ public void CumulativeSum(PrimitiveColumnContainer<ushort> column)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (ushort)(readOnlySpan[i] + ret);
                         mutableSpan[i] = ret;
@@ -5893,7 +5893,7 @@ public void Max(PrimitiveColumnContainer<ushort> column, out ushort? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (ushort)(Math.Max(readOnlySpan[i], value));
@@ -5941,7 +5941,7 @@ public void Min(PrimitiveColumnContainer<ushort> column, out ushort? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (ushort)(Math.Min(readOnlySpan[i], value));
@@ -5988,7 +5988,7 @@ public void Product(PrimitiveColumnContainer<ushort> column, out ushort? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         ret = (ushort)(readOnlySpan[i] * ret);
                     }
@@ -6033,7 +6033,7 @@ public void Sum(PrimitiveColumnContainer<ushort> column, out ushort? ret)
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
                         hasValue = true;
                         value = (ushort)(readOnlySpan[i] + value);
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.tt
index 4bea44c3f3..f33cb7ceb1 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.tt
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnComputations.tt
@@ -213,7 +213,7 @@ namespace Microsoft.Data.Analysis
 
                 for (int i = 0; i < readOnlySpan.Length; i++)
                 {
-                    if (BitmapHelper.IsValid(readOnlyBitMapSpan, i))
+                    if (BitUtility.IsValid(readOnlyBitMapSpan, i))
                     {
 <# if (method.MethodName == "CumulativeMax") { #>
                         ret = (<#=type.TypeName#>)(Math.Max(readOnlySpan[i], ret));
diff --git a/test/Microsoft.Data.Analysis.PerformanceTests/PerformanceTests.cs b/test/Microsoft.Data.Analysis.PerformanceTests/PerformanceTests.cs
index 7343200603..a9247b0ed7 100644
--- a/test/Microsoft.Data.Analysis.PerformanceTests/PerformanceTests.cs
+++ b/test/Microsoft.Data.Analysis.PerformanceTests/PerformanceTests.cs
@@ -198,5 +198,31 @@ public void Divide_Double_Float()
             var column = _doubleColumn1 / _floatColumn2;
         }
         #endregion
+
+        #region ElementwiseEquals
+        [Benchmark]
+        public void ElementwiseEquals_Int32_Int32()
+        {
+            var column = _int32Column1.ElementwiseEquals(_int32Column2);
+        }
+
+        [Benchmark]
+        public void ElementwiseEquals_Int16_Int16()
+        {
+            var column = _int32Column1.ElementwiseEquals(_int16Column2);
+        }
+
+        [Benchmark]
+        public void ElementwiseEquals_Double_Double()
+        {
+            var column = _doubleColumn1.ElementwiseEquals(_doubleColumn2);
+        }
+
+        [Benchmark]
+        public void ElementwiseEquals_Float_Float()
+        {
+            var column = _floatColumn1.ElementwiseEquals(_floatColumn2);
+        }
+        #endregion
     }
 }
diff --git a/test/Microsoft.Data.Analysis.Tests/DataFrameColumn.BinaryOperationTests.cs b/test/Microsoft.Data.Analysis.Tests/DataFrameColumn.BinaryOperationTests.cs
index dff229d559..03854c7c5e 100644
--- a/test/Microsoft.Data.Analysis.Tests/DataFrameColumn.BinaryOperationTests.cs
+++ b/test/Microsoft.Data.Analysis.Tests/DataFrameColumn.BinaryOperationTests.cs
@@ -170,7 +170,6 @@ public void AddByteToByteDataFrameColumn()
             Assert.Equal(columnResult.Length, verify.Count());
             Assert.True(columnResult.ElementwiseEquals(verifyColumn).All());
         }
-
         [Fact]
         public void AddDecimalToByteDataFrameColumn()
         {
diff --git a/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs b/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs
index 85e4ccd79c..2fb21c96ae 100644
--- a/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs
+++ b/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs
@@ -3662,8 +3662,8 @@ public void Test_StringColumnEqualsNull()
         public void Test_ArithmeticsSumWithNull()
         {
             // Arrange
-            var left_column = new PrimitiveDataFrameColumn<int>("Left", new int?[] { 1, 1, null, null });
-            var right_column = new PrimitiveDataFrameColumn<int>("Right", new int?[] { 1, null, 1, null });
+            var left_column = new Int32DataFrameColumn("Left", new int?[] { 1, 1, null, null });
+            var right_column = new Int32DataFrameColumn("Right", new int?[] { 1, null, 1, null });
 
             // Act
             var sum = left_column + right_column;
@@ -3681,11 +3681,11 @@ public void Test_ArithmeticsSumWithNull()
         public void Test_ArithmeticsDiffWithNull()
         {
             // Arrange
-            var left_column = new PrimitiveDataFrameColumn<int>("Left", new int?[] { 1, 1, null, null });
-            var right_column = new PrimitiveDataFrameColumn<int>("Right", new int?[] { 1, null, 1, null });
+            var left_column = new Int32DataFrameColumn("Left", new int?[] { 1, 1, null, null });
+            var right_column = new Int32DataFrameColumn("Right", new int?[] { 1, null, 1, null });
 
             // Act
-            var diff = left_column - right_column;
+            var diff = left_column - (right_column);
 
             // Assert
             Assert.Equal(3, diff.NullCount);
@@ -3699,15 +3699,15 @@ public void Test_ArithmeticsDiffWithNull()
         public void Test_ArithmeticsMultWithNull()
         {
             // Arrange
-            var left_column = new PrimitiveDataFrameColumn<int>("Left", new int?[] { 1, 1, null, null });
-            var right_column = new PrimitiveDataFrameColumn<int>("Right", new int?[] { 1, null, 1, null });
+            var left_column = new Int32DataFrameColumn("Left", new int?[] { 4, 1, null, null });
+            var right_column = new Int32DataFrameColumn("Right", new int?[] { 2, null, 1, null });
 
             // Act
             var mult = left_column * right_column;
 
             // Assert
             Assert.Equal(3, mult.NullCount);
-            Assert.Equal(1, mult[0]);  // 1 * 1
+            Assert.Equal(8, mult[0]);  // 1 * 1
             Assert.Null(mult[1]); // null * 1
             Assert.Null(mult[2]); // 1 * null
             Assert.Null(mult[3]); // null * null
@@ -3717,18 +3717,18 @@ public void Test_ArithmeticsMultWithNull()
         public void Test_ArithmeticsDivWithNull()
         {
             // Arrange
-            var left_column = new PrimitiveDataFrameColumn<int>("Left", new int?[] { 1, 1, null, null });
-            var right_column = new PrimitiveDataFrameColumn<int>("Right", new int?[] { 1, null, 1, null });
+            var left_column = new Int32DataFrameColumn("Left", new int?[] { 4, 1, null, null });
+            var right_column = new Int32DataFrameColumn("Right", new int?[] { 2, null, 1, null });
 
             // Act
-            var mult = left_column / right_column;
+            var div = left_column / right_column;
 
             // Assert
-            Assert.Equal(3, mult.NullCount);
-            Assert.Equal(1, mult[0]);  // 1 / 1
-            Assert.Null(mult[1]); // null / 1
-            Assert.Null(mult[2]); // 1 / null
-            Assert.Null(mult[3]); // null / null
+            Assert.Equal(3, div.NullCount);
+            Assert.Equal(2, div[0]);  // 1 / 1
+            Assert.Null(div[1]); // null / 1
+            Assert.Null(div[2]); // 1 / null
+            Assert.Null(div[3]); // null / null
         }
     }
 }