diff --git a/src/Microsoft.Data.Analysis/BitUtility.cs b/src/Microsoft.Data.Analysis/BitUtility.cs
index 783356dd13..a95a22e49e 100644
--- a/src/Microsoft.Data.Analysis/BitUtility.cs
+++ b/src/Microsoft.Data.Analysis/BitUtility.cs
@@ -137,12 +137,6 @@ public static void SetBits(Span<byte> data, long index, long length, bool 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.
@@ -167,7 +161,7 @@ public static long GetBitCount(ReadOnlySpan<byte> span, long length)
                 var partialByte = span[endByteIndex];
                 for (var j = 0; j < endBitOffset; j++)
                 {
-                    count += GetBit(partialByte, j) ? 0 : 1;
+                    count += GetBit(partialByte, j) ? 1 : 0;
                 }
             }
 
diff --git a/src/Microsoft.Data.Analysis/ColumnArithmetic.OperationEnums.cs b/src/Microsoft.Data.Analysis/ColumnArithmetic.OperationEnums.cs
index 79d1314520..4523b24bb2 100644
--- a/src/Microsoft.Data.Analysis/ColumnArithmetic.OperationEnums.cs
+++ b/src/Microsoft.Data.Analysis/ColumnArithmetic.OperationEnums.cs
@@ -18,18 +18,6 @@ internal enum BinaryOperation
         Xor,
     }
 
-    internal enum BinaryScalarOperation
-    {
-        Add,
-        Subtract,
-        Multiply,
-        Divide,
-        Modulo,
-        And,
-        Or,
-        Xor,
-    }
-
     internal enum BinaryIntOperation
     {
         LeftShift,
@@ -45,14 +33,4 @@ internal enum ComparisonOperation
         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
index 273091a8e7..993e02ae18 100644
--- a/src/Microsoft.Data.Analysis/ColumnArithmetic.OperationEnums.tt
+++ b/src/Microsoft.Data.Analysis/ColumnArithmetic.OperationEnums.tt
@@ -21,15 +21,6 @@ namespace Microsoft.Data.Analysis
 <# } #>
     }
 
-    internal enum BinaryScalarOperation
-    {
-<# foreach (MethodConfiguration method in methodConfiguration) { #>
-<# if (method.MethodType == MethodType.BinaryScalar) { #>
-        <#=method.MethodName#>,
-<# } #>
-<# } #>
-    }
-
     internal enum BinaryIntOperation
     {
 <# foreach (MethodConfiguration method in methodConfiguration) { #>
@@ -45,15 +36,6 @@ namespace Microsoft.Data.Analysis
 <# 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/ColumnArithmeticTemplate.ttinclude b/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude
index 2294023439..c99795cc13 100644
--- a/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude
+++ b/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude
@@ -6,7 +6,7 @@
 <#+
     public class TypeConfiguration
     {
-        public TypeConfiguration(string typeName, string classPrefix = null, string oneLiteral = "1", string zeroLiteral = "0", bool supportsNumeric = true, bool supportsBitwise = true, IEnumerable<string> unsupportedMethods = null)
+        public TypeConfiguration(string typeName, string classPrefix = null, string oneLiteral = "1", string zeroLiteral = "0", bool supportsNumeric = true, bool supportsBitwise = true, IEnumerable<string> unsupportedMethods = null, bool supportsVectorization = false)
         {
             TypeName = typeName;
             ClassPrefix = classPrefix ?? char.ToUpper(typeName[0]) + typeName.Substring(1);
@@ -14,6 +14,7 @@
             ZeroLiteral = zeroLiteral;
             SupportsNumeric = supportsNumeric;
             SupportsBitwise = supportsBitwise;
+            SupportsVectorization = supportsVectorization;
             UnsupportedMethods = new HashSet<string>(unsupportedMethods ?? Enumerable.Empty<string>());
         }
 
@@ -24,14 +25,11 @@
         
         public bool SupportsNumeric { get; }
         public bool SupportsBitwise { get; }
-        public ISet<string> UnsupportedMethods { get; }
-    }
+        public bool SupportsVectorization { get; }
 
-    public string GenerateInPlaceStatement(string trueCondition, string falseCondition)
-    {
-        return $"inPlace ? {trueCondition} : {falseCondition}";
+        public ISet<string> UnsupportedMethods { get; }
     }
-
+        
     public string GenerateIfStatementHeader(TypeConfiguration type)
     {
         string keyword = (type == typeConfiguration[0]) ? "if" : "else if";
@@ -139,18 +137,18 @@
     public TypeConfiguration[] typeConfiguration = new []
     {
         new TypeConfiguration("bool", oneLiteral:"true", zeroLiteral:"false", supportsNumeric: false, unsupportedMethods: new[] {"LeftShift", "RightShift"}),
-        new TypeConfiguration("byte", unsupportedMethods: new[] {"All", "Any"}),
-        new TypeConfiguration("char", oneLiteral:"(char)1", zeroLiteral:"(char)0", unsupportedMethods: new[] {"All", "Any"}),
+        new TypeConfiguration("byte", unsupportedMethods: new[] {"All", "Any"}, supportsVectorization: true),
+        new TypeConfiguration("char", oneLiteral:"(char)1", zeroLiteral:"(char)0", unsupportedMethods: new[] {"All", "Any"}, supportsVectorization: true),
         new TypeConfiguration("decimal", supportsBitwise: false, unsupportedMethods: new[] {"All", "Any"}),
-        new TypeConfiguration("double", oneLiteral:"1.0", supportsBitwise: false, unsupportedMethods: new[] {"All", "Any"}),
-        new TypeConfiguration("float", oneLiteral:"1.0f", supportsBitwise: false, unsupportedMethods: new[] {"All", "Any"}),
-        new TypeConfiguration("int", unsupportedMethods: new[] {"All", "Any"}),
-        new TypeConfiguration("long", unsupportedMethods: new[] {"All", "Any"}),
-        new TypeConfiguration("sbyte", classPrefix:"SByte", unsupportedMethods: new[] {"All", "Any"}),
-        new TypeConfiguration("short", unsupportedMethods: new[] {"All", "Any"}),
-        new TypeConfiguration("uint", classPrefix:"UInt", unsupportedMethods: new[] {"UnaryMinus", "All", "Any"}),
-        new TypeConfiguration("ulong", classPrefix:"ULong", unsupportedMethods: new[] {"UnaryMinus", "All", "Any"}),
-        new TypeConfiguration("ushort", classPrefix:"UShort", unsupportedMethods: new[] {"UnaryMinus", "All", "Any"}),
+        new TypeConfiguration("double", oneLiteral:"1.0", supportsBitwise: false, unsupportedMethods: new[] {"All", "Any"}, supportsVectorization: true),
+        new TypeConfiguration("float", oneLiteral:"1.0f", supportsBitwise: false, unsupportedMethods: new[] {"All", "Any"}, supportsVectorization: true),
+        new TypeConfiguration("int", unsupportedMethods: new[] {"All", "Any"}, supportsVectorization: true),
+        new TypeConfiguration("long", unsupportedMethods: new[] {"All", "Any"}, supportsVectorization: true),
+        new TypeConfiguration("sbyte", classPrefix:"SByte", unsupportedMethods: new[] {"All", "Any"}, supportsVectorization: true),
+        new TypeConfiguration("short", unsupportedMethods: new[] {"All", "Any"}, supportsVectorization: true),
+        new TypeConfiguration("uint", classPrefix:"UInt", unsupportedMethods: new[] {"UnaryMinus", "All", "Any"}, supportsVectorization: true),
+        new TypeConfiguration("ulong", classPrefix:"ULong", unsupportedMethods: new[] {"UnaryMinus", "All", "Any"}, supportsVectorization: true),
+        new TypeConfiguration("ushort", classPrefix:"UShort", unsupportedMethods: new[] {"UnaryMinus", "All", "Any"}, supportsVectorization: true),
         new TypeConfiguration("DateTime", supportsBitwise: false, supportsNumeric: false, unsupportedMethods: new[] {"And", "Or", "Xor"})
     };
 
@@ -227,16 +225,16 @@
         new MethodConfiguration("Sum", MethodType.Reduction, "+", isNumeric:true, hasReturnValue:true, supportsRowSubsets: true, methodComments: "Returns the sum of the values at the rowIndices"),
         new MethodConfiguration("Round", MethodType.ElementwiseComputation, "Math.Round", isNumeric:true, methodComments: "Calls Math.Round on each value in a column"),
     };
-
+        
     public MethodConfiguration[] methodConfiguration = new [] 
     {
-        new MethodConfiguration("Add", MethodType.Binary, "+", isNumeric:true, methodComments: "Performs element-wise addition"),
+        new MethodConfiguration("Add", MethodType.Binary, "+", isNumeric:true, methodComments: "Performs element-wise addition", supportsVectorization: true),
         new MethodConfiguration("Add", MethodType.BinaryScalar, "+", isNumeric:true, methodComments: "Performs an element-wise addition on each column"),
-        new MethodConfiguration("Subtract", MethodType.Binary, "-", isNumeric:true, methodComments: "Performs element-wise subtraction"),
+        new MethodConfiguration("Subtract", MethodType.Binary, "-", isNumeric:true, methodComments: "Performs element-wise subtraction", supportsVectorization: true),
         new MethodConfiguration("Subtract", MethodType.BinaryScalar, "-", isNumeric:true, methodComments: "Performs an element-wise subtraction on each column"),
-        new MethodConfiguration("Multiply", MethodType.Binary, "*", isNumeric:true, methodComments: "Performs element-wise multiplication"),  // element-wise product, not matrix product
+        new MethodConfiguration("Multiply", MethodType.Binary, "*", isNumeric:true, methodComments: "Performs element-wise multiplication", supportsVectorization: true),
         new MethodConfiguration("Multiply", MethodType.BinaryScalar, "*", isNumeric:true, methodComments: "Performs an element-wise multiplication on each column"),
-        new MethodConfiguration("Divide", MethodType.Binary, "/", isNumeric:true, methodComments: "Performs element-wise division"),
+        new MethodConfiguration("Divide", MethodType.Binary, "/", isNumeric:true, methodComments: "Performs element-wise division", supportsVectorization: true),
         new MethodConfiguration("Divide", MethodType.BinaryScalar, "/", isNumeric:true, methodComments: "Performs an element-wise division on each column"),
         new MethodConfiguration("Modulo", MethodType.Binary, "%", isNumeric:true, methodComments: "Performs element-wise modulus"),
         new MethodConfiguration("Modulo", MethodType.BinaryScalar, "%", isNumeric:true, methodComments: "Performs an element-wise modulus operation on each column"),
@@ -265,7 +263,7 @@
 
      public class MethodConfiguration
     {
-        public MethodConfiguration(string methodName, MethodType methodType, string op = null, bool isNumeric = false, bool isBitwise = false, bool hasReturnValue = false, bool supportsRowSubsets = false, string methodComments = null)
+        public MethodConfiguration(string methodName, MethodType methodType, string op = null, bool isNumeric = false, bool isBitwise = false, bool hasReturnValue = false, bool supportsRowSubsets = false, string methodComments = null, bool supportsVectorization = false)
         {
             MethodName = methodName;
             MethodType = methodType;
@@ -275,6 +273,7 @@
             HasReturnValue = hasReturnValue;
             SupportsRowSubsets = supportsRowSubsets;
             MethodComments = methodComments;
+            SupportsVectorization = supportsVectorization;
         }
 
         public string ResultName => "result";
@@ -330,7 +329,7 @@
         public MethodType MethodType { get; }
         public string Operator { get; }
         public string MethodComments { get; }
-        
+        public bool SupportsVectorization { get; }        
         public string GetColumnSpecificMethodComments()
         {
             var str = MethodComments;
diff --git a/src/Microsoft.Data.Analysis/Computations/Arithmetic.cs b/src/Microsoft.Data.Analysis/Computations/Arithmetic.cs
new file mode 100644
index 0000000000..e98acbdeee
--- /dev/null
+++ b/src/Microsoft.Data.Analysis/Computations/Arithmetic.cs
@@ -0,0 +1,328 @@
+
+// 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 Arithmetic.tt. Do not modify directly
+
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace Microsoft.Data.Analysis
+{
+    ////////////////////////////////////////
+    //Factory Class                       //
+    ////////////////////////////////////////
+
+    internal static class Arithmetic
+    {
+        public static IArithmetic<T> GetArithmetic<T>()
+            where T : unmanaged
+        {
+            if (typeof(T) == typeof(bool))
+                return (IArithmetic<T>)new BoolArithmetic();
+            else if (typeof(T) == typeof(byte))
+                return (IArithmetic<T>)new ByteArithmetic();
+            else if (typeof(T) == typeof(char))
+                return (IArithmetic<T>)new CharArithmetic();
+            else if (typeof(T) == typeof(decimal))
+                return (IArithmetic<T>)new DecimalArithmetic();
+            else if (typeof(T) == typeof(double))
+                return (IArithmetic<T>)new DoubleArithmetic();
+            else if (typeof(T) == typeof(float))
+                return (IArithmetic<T>)new FloatArithmetic();
+            else if (typeof(T) == typeof(int))
+                return (IArithmetic<T>)new IntArithmetic();
+            else if (typeof(T) == typeof(long))
+                return (IArithmetic<T>)new LongArithmetic();
+            else if (typeof(T) == typeof(sbyte))
+                return (IArithmetic<T>)new SByteArithmetic();
+            else if (typeof(T) == typeof(short))
+                return (IArithmetic<T>)new ShortArithmetic();
+            else if (typeof(T) == typeof(uint))
+                return (IArithmetic<T>)new UIntArithmetic();
+            else if (typeof(T) == typeof(ulong))
+                return (IArithmetic<T>)new ULongArithmetic();
+            else if (typeof(T) == typeof(ushort))
+                return (IArithmetic<T>)new UShortArithmetic();
+            else if (typeof(T) == typeof(DateTime))
+                return (IArithmetic<T>)new DateTimeArithmetic();
+            throw new NotSupportedException();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ref Vector<T> AsVector<T>(ref T start, int offset)
+            where T : struct => ref Unsafe.As<T, Vector<T>>(ref Unsafe.Add(ref start, offset));
+    }
+
+
+    ////////////////////////////////////////
+    //Base Class for Arithmetic           //
+    ////////////////////////////////////////
+
+    internal class Arithmetic<T> : IArithmetic<T>
+        where T : unmanaged
+    {
+        public static IArithmetic<T> Instance { get; } = Arithmetic.GetArithmetic<T>();
+
+
+        //Binary operations
+
+        public void HandleOperation(BinaryOperation operation, ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+        {
+            switch (operation)
+            {
+                case BinaryOperation.Add:
+                    Add(x, y, destination);
+                    break;
+                case BinaryOperation.Subtract:
+                    Subtract(x, y, destination);
+                    break;
+                case BinaryOperation.Multiply:
+                    Multiply(x, y, destination);
+                    break;
+                case BinaryOperation.Divide:
+                    Divide(x, y, destination);
+                    break;
+                case BinaryOperation.Modulo:
+                    Modulo(x, y, destination);
+                    break;
+                case BinaryOperation.And:
+                    And(x, y, destination);
+                    break;
+                case BinaryOperation.Or:
+                    Or(x, y, destination);
+                    break;
+                case BinaryOperation.Xor:
+                    Xor(x, y, destination);
+                    break;
+            }
+        }
+
+        public void HandleOperation(BinaryOperation operation, ReadOnlySpan<T> x, T y, Span<T> destination)
+        {
+            switch (operation)
+            {
+                case BinaryOperation.Add:
+                    Add(x, y, destination);
+                    break;
+                case BinaryOperation.Subtract:
+                    Subtract(x, y, destination);
+                    break;
+                case BinaryOperation.Multiply:
+                    Multiply(x, y, destination);
+                    break;
+                case BinaryOperation.Divide:
+                    Divide(x, y, destination);
+                    break;
+                case BinaryOperation.Modulo:
+                    Modulo(x, y, destination);
+                    break;
+                case BinaryOperation.And:
+                    And(x, y, destination);
+                    break;
+                case BinaryOperation.Or:
+                    Or(x, y, destination);
+                    break;
+                case BinaryOperation.Xor:
+                    Xor(x, y, destination);
+                    break;
+            }
+        }
+
+        public void HandleOperation(BinaryOperation operation, T x, ReadOnlySpan<T> y, Span<T> destination)
+        {
+            switch (operation)
+            {
+                case BinaryOperation.Add:
+                    Add(x, y, destination);
+                    break;
+                case BinaryOperation.Subtract:
+                    Subtract(x, y, destination);
+                    break;
+                case BinaryOperation.Multiply:
+                    Multiply(x, y, destination);
+                    break;
+                case BinaryOperation.Divide:
+                    Divide(x, y, destination);
+                    break;
+                case BinaryOperation.Modulo:
+                    Modulo(x, y, destination);
+                    break;
+                case BinaryOperation.And:
+                    And(x, y, destination);
+                    break;
+                case BinaryOperation.Or:
+                    Or(x, y, destination);
+                    break;
+                case BinaryOperation.Xor:
+                    Xor(x, y, destination);
+                    break;
+            }
+        }
+
+        public T HandleOperation(BinaryOperation operation, T x, T y)
+        {
+            if (operation == BinaryOperation.Divide)
+                return Divide(x, y);
+
+            if (operation == BinaryOperation.Modulo)
+                return Modulo(x, y);
+
+            throw new NotSupportedException();
+        }
+
+
+        //Binary Int operations
+
+        public void HandleOperation(BinaryIntOperation operation, ReadOnlySpan<T> x, int y, Span<T> destination)
+        {
+            switch (operation)
+            {
+                case BinaryIntOperation.LeftShift:
+                    LeftShift(x, y, destination);
+                    break;
+                case BinaryIntOperation.RightShift:
+                    RightShift(x, y, destination);
+                    break;
+            }
+        }
+
+
+        //Comparison operations
+
+        public void HandleOperation(ComparisonOperation operation, ReadOnlySpan<T> x, ReadOnlySpan<T> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            switch (operation)
+            {
+                case ComparisonOperation.ElementwiseEquals:
+                    ElementwiseEquals(x, y, result, offset);
+                    break;
+                case ComparisonOperation.ElementwiseNotEquals:
+                    ElementwiseNotEquals(x, y, result, offset);
+                    break;
+                case ComparisonOperation.ElementwiseGreaterThanOrEqual:
+                    ElementwiseGreaterThanOrEqual(x, y, result, offset);
+                    break;
+                case ComparisonOperation.ElementwiseLessThanOrEqual:
+                    ElementwiseLessThanOrEqual(x, y, result, offset);
+                    break;
+                case ComparisonOperation.ElementwiseGreaterThan:
+                    ElementwiseGreaterThan(x, y, result, offset);
+                    break;
+                case ComparisonOperation.ElementwiseLessThan:
+                    ElementwiseLessThan(x, y, result, offset);
+                    break;
+            }
+        }
+
+        public void HandleOperation(ComparisonOperation operation, ReadOnlySpan<T> x, T y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            switch (operation)
+            {
+                case ComparisonOperation.ElementwiseEquals:
+                    ElementwiseEquals(x, y, result, offset);
+                    break;
+                case ComparisonOperation.ElementwiseNotEquals:
+                    ElementwiseNotEquals(x, y, result, offset);
+                    break;
+                case ComparisonOperation.ElementwiseGreaterThanOrEqual:
+                    ElementwiseGreaterThanOrEqual(x, y, result, offset);
+                    break;
+                case ComparisonOperation.ElementwiseLessThanOrEqual:
+                    ElementwiseLessThanOrEqual(x, y, result, offset);
+                    break;
+                case ComparisonOperation.ElementwiseGreaterThan:
+                    ElementwiseGreaterThan(x, y, result, offset);
+                    break;
+                case ComparisonOperation.ElementwiseLessThan:
+                    ElementwiseLessThan(x, y, result, offset);
+                    break;
+            }
+        }
+
+
+        //Protected methods
+
+        protected virtual void Add(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Add(ReadOnlySpan<T> x, T y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Add(T x, ReadOnlySpan<T> y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Subtract(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Subtract(ReadOnlySpan<T> x, T y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Subtract(T x, ReadOnlySpan<T> y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Multiply(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Multiply(ReadOnlySpan<T> x, T y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Multiply(T x, ReadOnlySpan<T> y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Divide(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Divide(ReadOnlySpan<T> x, T y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Divide(T x, ReadOnlySpan<T> y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Modulo(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Modulo(ReadOnlySpan<T> x, T y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Modulo(T x, ReadOnlySpan<T> y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void And(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void And(ReadOnlySpan<T> x, T y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void And(T x, ReadOnlySpan<T> y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Or(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Or(ReadOnlySpan<T> x, T y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Or(T x, ReadOnlySpan<T> y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Xor(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Xor(ReadOnlySpan<T> x, T y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void Xor(T x, ReadOnlySpan<T> y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void LeftShift(ReadOnlySpan<T> x, int y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void RightShift(ReadOnlySpan<T> x, int y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void ElementwiseEquals(ReadOnlySpan<T> x, ReadOnlySpan<T> y, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+
+        protected virtual void ElementwiseEquals(ReadOnlySpan<T> x, T y, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+
+        protected virtual void ElementwiseNotEquals(ReadOnlySpan<T> x, ReadOnlySpan<T> y, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+
+        protected virtual void ElementwiseNotEquals(ReadOnlySpan<T> x, T y, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+
+        protected virtual void ElementwiseGreaterThanOrEqual(ReadOnlySpan<T> x, ReadOnlySpan<T> y, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+
+        protected virtual void ElementwiseGreaterThanOrEqual(ReadOnlySpan<T> x, T y, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+
+        protected virtual void ElementwiseLessThanOrEqual(ReadOnlySpan<T> x, ReadOnlySpan<T> y, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+
+        protected virtual void ElementwiseLessThanOrEqual(ReadOnlySpan<T> x, T y, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+
+        protected virtual void ElementwiseGreaterThan(ReadOnlySpan<T> x, ReadOnlySpan<T> y, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+
+        protected virtual void ElementwiseGreaterThan(ReadOnlySpan<T> x, T y, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+
+        protected virtual void ElementwiseLessThan(ReadOnlySpan<T> x, ReadOnlySpan<T> y, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+
+        protected virtual void ElementwiseLessThan(ReadOnlySpan<T> x, T y, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+
+        protected virtual T Divide(T x, T y) => throw new NotSupportedException();
+
+        protected virtual T Modulo(T x, T y) => throw new NotSupportedException();
+    }
+}
diff --git a/src/Microsoft.Data.Analysis/Computations/Arithmetic.tt b/src/Microsoft.Data.Analysis/Computations/Arithmetic.tt
new file mode 100644
index 0000000000..426bfeda37
--- /dev/null
+++ b/src/Microsoft.Data.Analysis/Computations/Arithmetic.tt
@@ -0,0 +1,185 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ assembly name="System" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ output extension=".cs" #>
+<#@ include file="$(ProjectDir)\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 Arithmetic.tt. Do not modify directly
+
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace Microsoft.Data.Analysis
+{
+    ////////////////////////////////////////
+    //Factory Class                       //
+    ////////////////////////////////////////
+
+    internal static class Arithmetic
+    {
+        public static IArithmetic<T> GetArithmetic<T>()
+            where T : unmanaged
+        {
+<# foreach (TypeConfiguration type in typeConfiguration) { #>
+            <#=GenerateIfStatementHeader(type)#>
+                return (IArithmetic<T>)new <#=type.ClassPrefix#>Arithmetic();
+<# } #>
+            throw new NotSupportedException();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ref Vector<T> AsVector<T>(ref T start, int offset)
+            where T : struct => ref Unsafe.As<T, Vector<T>>(ref Unsafe.Add(ref start, offset));
+    }
+
+
+    ////////////////////////////////////////
+    //Base Class for Arithmetic           //
+    ////////////////////////////////////////
+
+    internal class Arithmetic<T> : IArithmetic<T>
+        where T : unmanaged
+    {
+        public static IArithmetic<T> Instance { get; } = Arithmetic.GetArithmetic<T>();
+
+
+        //Binary operations
+
+        public void HandleOperation(BinaryOperation operation, ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+        {
+            switch (operation)
+            {
+<# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (method.MethodType == MethodType.Binary) { #>
+                case BinaryOperation.<#=method.MethodName#>:
+                    <#=method.MethodName#>(x, y, destination);
+                    break;
+<# } #>
+<# } #>
+            }
+        }
+
+        public void HandleOperation(BinaryOperation operation, ReadOnlySpan<T> x, T y, Span<T> destination)
+        {
+            switch (operation)
+            {
+<# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (method.MethodType == MethodType.BinaryScalar) { #>
+                case BinaryOperation.<#=method.MethodName#>:
+                    <#=method.MethodName#>(x, y, destination);
+                    break;
+<# } #>
+<# } #>
+            }
+        }
+
+        public void HandleOperation(BinaryOperation operation, T x, ReadOnlySpan<T> y, Span<T> destination)
+        {
+            switch (operation)
+            {
+<# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (method.MethodType == MethodType.BinaryScalar) { #>
+                case BinaryOperation.<#=method.MethodName#>:
+                    <#=method.MethodName#>(x, y, destination);
+                    break;
+<# } #>
+<# } #>
+            }
+        }
+
+        public T HandleOperation(BinaryOperation operation, T x, T y)
+        {
+            if (operation == BinaryOperation.Divide)
+                return Divide(x, y);
+
+            if (operation == BinaryOperation.Modulo)
+                return Modulo(x, y);
+
+            throw new NotSupportedException();
+        }
+
+
+        //Binary Int operations
+
+        public void HandleOperation(BinaryIntOperation operation, ReadOnlySpan<T> x, int y, Span<T> destination)
+        {
+            switch (operation)
+            {
+<# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (method.MethodType == MethodType.BinaryInt) { #>
+                case BinaryIntOperation.<#=method.MethodName#>:
+                    <#=method.MethodName#>(x, y, destination);
+                    break;
+<# } #>
+<# } #>
+            }
+        }
+
+
+        //Comparison operations
+
+        public void HandleOperation(ComparisonOperation operation, ReadOnlySpan<T> x, ReadOnlySpan<T> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            switch (operation)
+            {
+<# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (method.MethodType == MethodType.Comparison) { #>
+                case ComparisonOperation.<#=method.MethodName#>:
+                    <#=method.MethodName#>(x, y, result, offset);
+                    break;
+<# } #>
+<# } #>
+            }
+        }
+
+        public void HandleOperation(ComparisonOperation operation, ReadOnlySpan<T> x, T y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            switch (operation)
+            {
+<# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (method.MethodType == MethodType.ComparisonScalar) { #>
+                case ComparisonOperation.<#=method.MethodName#>:
+                    <#=method.MethodName#>(x, y, result, offset);
+                    break;
+<# } #>
+<# } #>
+            }
+        }
+
+
+        //Protected methods
+<# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (method.MethodType == MethodType.Comparison) { #>
+
+        protected virtual void <#=method.MethodName#>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+<# } #>
+<# else if (method.MethodType == MethodType.ComparisonScalar) { #>
+
+        protected virtual void <#=method.MethodName#>(ReadOnlySpan<T> x, T y, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
+<# } #>
+<# else if (method.MethodType == MethodType.Binary) { #>
+
+        protected virtual void <#=method.MethodName#>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination) => throw new NotSupportedException();
+<# } else if (method.MethodType == MethodType.BinaryScalar) { #>
+
+        protected virtual void <#=method.MethodName#>(ReadOnlySpan<T> x, T y, Span<T> destination) => throw new NotSupportedException();
+
+        protected virtual void <#=method.MethodName#>(T x, ReadOnlySpan<T> y, Span<T> destination) => throw new NotSupportedException();
+<# } else if (method.MethodType == MethodType.BinaryInt) { #>
+
+        protected virtual void <#=method.MethodName#>(ReadOnlySpan<T> x, int y, Span<T> destination) => throw new NotSupportedException();
+<# } #>
+<# } #>
+
+        protected virtual T Divide(T x, T y) => throw new NotSupportedException();
+
+        protected virtual T Modulo(T x, T y) => throw new NotSupportedException();
+    }
+}
diff --git a/src/Microsoft.Data.Analysis/Computations/Arithmetics.cs b/src/Microsoft.Data.Analysis/Computations/Arithmetics.cs
new file mode 100644
index 0000000000..4de6a52677
--- /dev/null
+++ b/src/Microsoft.Data.Analysis/Computations/Arithmetics.cs
@@ -0,0 +1,5394 @@
+
+// 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 Arithmetics.tt. Do not modify directly
+
+using System;
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Data.Analysis
+{
+    internal class BoolArithmetic : Arithmetic<bool>
+    {
+
+        protected override void And(ReadOnlySpan<bool> x, ReadOnlySpan<bool> y, Span<bool> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (bool)(x[i] & y[i]);
+                i++;
+            }
+        }
+
+        protected override void And(ReadOnlySpan<bool> x, bool y, Span<bool> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (bool)(x[i] & y);
+                i++;
+            }
+        }
+
+        protected override void And(bool x, ReadOnlySpan<bool> y, Span<bool> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (bool)(x & y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<bool> x, ReadOnlySpan<bool> y, Span<bool> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (bool)(x[i] | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<bool> x, bool y, Span<bool> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (bool)(x[i] | y);
+                i++;
+            }
+        }
+
+        protected override void Or(bool x, ReadOnlySpan<bool> y, Span<bool> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (bool)(x | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<bool> x, ReadOnlySpan<bool> y, Span<bool> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (bool)(x[i] ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<bool> x, bool y, Span<bool> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (bool)(x[i] ^ y);
+                i++;
+            }
+        }
+
+        protected override void Xor(bool x, ReadOnlySpan<bool> y, Span<bool> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (bool)(x ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<bool> x, ReadOnlySpan<bool> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y[i]);
+            }
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<bool> x, bool y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<bool> x, ReadOnlySpan<bool> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y[i]);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<bool> x, bool y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y);
+            }
+        }
+    }
+    internal class ByteArithmetic : Arithmetic<byte>
+    {
+
+        protected override void Add(ReadOnlySpan<byte> x, ReadOnlySpan<byte> y, Span<byte> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref byte xRef = ref MemoryMarshal.GetReference(x);
+                ref byte yRef = ref MemoryMarshal.GetReference(y);
+                ref byte dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<byte>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) + Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (byte)(x[i] + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Add(ReadOnlySpan<byte> x, byte y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (byte)(x[i] + y);
+                i++;
+            }
+        }
+
+        protected override void Add(byte x, ReadOnlySpan<byte> y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (byte)(x + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<byte> x, ReadOnlySpan<byte> y, Span<byte> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref byte xRef = ref MemoryMarshal.GetReference(x);
+                ref byte yRef = ref MemoryMarshal.GetReference(y);
+                ref byte dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<byte>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) - Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (byte)(x[i] - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<byte> x, byte y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (byte)(x[i] - y);
+                i++;
+            }
+        }
+
+        protected override void Subtract(byte x, ReadOnlySpan<byte> y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (byte)(x - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<byte> x, ReadOnlySpan<byte> y, Span<byte> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref byte xRef = ref MemoryMarshal.GetReference(x);
+                ref byte yRef = ref MemoryMarshal.GetReference(y);
+                ref byte dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<byte>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) * Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (byte)(x[i] * y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<byte> x, byte y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (byte)(x[i] * y);
+                i++;
+            }
+        }
+
+        protected override void Multiply(byte x, ReadOnlySpan<byte> y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (byte)(x * y[i]);
+                i++;
+            }
+        }
+
+        protected override byte Divide(byte x, byte y)
+        {
+            return (byte)(x / y);
+        }
+
+        protected override void Divide(ReadOnlySpan<byte> x, ReadOnlySpan<byte> y, Span<byte> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref byte xRef = ref MemoryMarshal.GetReference(x);
+                ref byte yRef = ref MemoryMarshal.GetReference(y);
+                ref byte dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<byte>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) / Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (byte)(x[i] / y[i]);
+                i++;
+            }
+        }
+
+        protected override void Divide(ReadOnlySpan<byte> x, byte y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (byte)(x[i] / y);
+                i++;
+            }
+        }
+
+        protected override void Divide(byte x, ReadOnlySpan<byte> y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (byte)(x / y[i]);
+                i++;
+            }
+        }
+
+        protected override byte Modulo(byte x, byte y)
+        {
+            return (byte)(x % y);
+        }
+
+        protected override void Modulo(ReadOnlySpan<byte> x, ReadOnlySpan<byte> y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (byte)(x[i] % y[i]);
+                i++;
+            }
+        }
+
+        protected override void Modulo(ReadOnlySpan<byte> x, byte y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (byte)(x[i] % y);
+                i++;
+            }
+        }
+
+        protected override void Modulo(byte x, ReadOnlySpan<byte> y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (byte)(x % y[i]);
+                i++;
+            }
+        }
+
+        protected override void And(ReadOnlySpan<byte> x, ReadOnlySpan<byte> y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (byte)(x[i] & y[i]);
+                i++;
+            }
+        }
+
+        protected override void And(ReadOnlySpan<byte> x, byte y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (byte)(x[i] & y);
+                i++;
+            }
+        }
+
+        protected override void And(byte x, ReadOnlySpan<byte> y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (byte)(x & y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<byte> x, ReadOnlySpan<byte> y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (byte)(x[i] | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<byte> x, byte y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (byte)(x[i] | y);
+                i++;
+            }
+        }
+
+        protected override void Or(byte x, ReadOnlySpan<byte> y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (byte)(x | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<byte> x, ReadOnlySpan<byte> y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (byte)(x[i] ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<byte> x, byte y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (byte)(x[i] ^ y);
+                i++;
+            }
+        }
+
+        protected override void Xor(byte x, ReadOnlySpan<byte> y, Span<byte> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (byte)(x ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void LeftShift(ReadOnlySpan<byte> x, int y, Span<byte> destination)
+        {
+            for (var i = 0; i < x.Length; i++)
+                destination[i] = (byte)(x[i] << y);
+        }
+
+        protected override void RightShift(ReadOnlySpan<byte> x, int y, Span<byte> destination)
+        {
+            for (var i = 0; i < x.Length; i++)
+                destination[i] = (byte)(x[i] >> y);
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<byte> x, ReadOnlySpan<byte> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y[i]);
+            }
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<byte> x, byte y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<byte> x, ReadOnlySpan<byte> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y[i]);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<byte> x, byte y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<byte> x, ReadOnlySpan<byte> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<byte> x, byte y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<byte> x, ReadOnlySpan<byte> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<byte> x, byte y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<byte> x, ReadOnlySpan<byte> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<byte> x, byte y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<byte> x, ReadOnlySpan<byte> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<byte> x, byte y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y);
+            }
+        }
+    }
+    internal class CharArithmetic : Arithmetic<char>
+    {
+
+        protected override void Add(ReadOnlySpan<char> x, ReadOnlySpan<char> y, Span<char> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref char xRef = ref MemoryMarshal.GetReference(x);
+                ref char yRef = ref MemoryMarshal.GetReference(y);
+                ref char dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<char>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) + Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (char)(x[i] + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Add(ReadOnlySpan<char> x, char y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (char)(x[i] + y);
+                i++;
+            }
+        }
+
+        protected override void Add(char x, ReadOnlySpan<char> y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (char)(x + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<char> x, ReadOnlySpan<char> y, Span<char> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref char xRef = ref MemoryMarshal.GetReference(x);
+                ref char yRef = ref MemoryMarshal.GetReference(y);
+                ref char dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<char>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) - Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (char)(x[i] - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<char> x, char y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (char)(x[i] - y);
+                i++;
+            }
+        }
+
+        protected override void Subtract(char x, ReadOnlySpan<char> y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (char)(x - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<char> x, ReadOnlySpan<char> y, Span<char> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref char xRef = ref MemoryMarshal.GetReference(x);
+                ref char yRef = ref MemoryMarshal.GetReference(y);
+                ref char dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<char>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) * Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (char)(x[i] * y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<char> x, char y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (char)(x[i] * y);
+                i++;
+            }
+        }
+
+        protected override void Multiply(char x, ReadOnlySpan<char> y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (char)(x * y[i]);
+                i++;
+            }
+        }
+
+        protected override char Divide(char x, char y)
+        {
+            return (char)(x / y);
+        }
+
+        protected override void Divide(ReadOnlySpan<char> x, ReadOnlySpan<char> y, Span<char> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref char xRef = ref MemoryMarshal.GetReference(x);
+                ref char yRef = ref MemoryMarshal.GetReference(y);
+                ref char dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<char>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) / Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (char)(x[i] / y[i]);
+                i++;
+            }
+        }
+
+        protected override void Divide(ReadOnlySpan<char> x, char y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (char)(x[i] / y);
+                i++;
+            }
+        }
+
+        protected override void Divide(char x, ReadOnlySpan<char> y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (char)(x / y[i]);
+                i++;
+            }
+        }
+
+        protected override char Modulo(char x, char y)
+        {
+            return (char)(x % y);
+        }
+
+        protected override void Modulo(ReadOnlySpan<char> x, ReadOnlySpan<char> y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (char)(x[i] % y[i]);
+                i++;
+            }
+        }
+
+        protected override void Modulo(ReadOnlySpan<char> x, char y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (char)(x[i] % y);
+                i++;
+            }
+        }
+
+        protected override void Modulo(char x, ReadOnlySpan<char> y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (char)(x % y[i]);
+                i++;
+            }
+        }
+
+        protected override void And(ReadOnlySpan<char> x, ReadOnlySpan<char> y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (char)(x[i] & y[i]);
+                i++;
+            }
+        }
+
+        protected override void And(ReadOnlySpan<char> x, char y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (char)(x[i] & y);
+                i++;
+            }
+        }
+
+        protected override void And(char x, ReadOnlySpan<char> y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (char)(x & y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<char> x, ReadOnlySpan<char> y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (char)(x[i] | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<char> x, char y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (char)(x[i] | y);
+                i++;
+            }
+        }
+
+        protected override void Or(char x, ReadOnlySpan<char> y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (char)(x | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<char> x, ReadOnlySpan<char> y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (char)(x[i] ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<char> x, char y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (char)(x[i] ^ y);
+                i++;
+            }
+        }
+
+        protected override void Xor(char x, ReadOnlySpan<char> y, Span<char> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (char)(x ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void LeftShift(ReadOnlySpan<char> x, int y, Span<char> destination)
+        {
+            for (var i = 0; i < x.Length; i++)
+                destination[i] = (char)(x[i] << y);
+        }
+
+        protected override void RightShift(ReadOnlySpan<char> x, int y, Span<char> destination)
+        {
+            for (var i = 0; i < x.Length; i++)
+                destination[i] = (char)(x[i] >> y);
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<char> x, ReadOnlySpan<char> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y[i]);
+            }
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<char> x, char y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<char> x, ReadOnlySpan<char> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y[i]);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<char> x, char y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<char> x, ReadOnlySpan<char> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<char> x, char y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<char> x, ReadOnlySpan<char> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<char> x, char y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<char> x, ReadOnlySpan<char> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<char> x, char y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<char> x, ReadOnlySpan<char> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<char> x, char y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y);
+            }
+        }
+    }
+    internal class DecimalArithmetic : Arithmetic<decimal>
+    {
+
+        protected override void Add(ReadOnlySpan<decimal> x, ReadOnlySpan<decimal> y, Span<decimal> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (decimal)(x[i] + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Add(ReadOnlySpan<decimal> x, decimal y, Span<decimal> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (decimal)(x[i] + y);
+                i++;
+            }
+        }
+
+        protected override void Add(decimal x, ReadOnlySpan<decimal> y, Span<decimal> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (decimal)(x + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<decimal> x, ReadOnlySpan<decimal> y, Span<decimal> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (decimal)(x[i] - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<decimal> x, decimal y, Span<decimal> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (decimal)(x[i] - y);
+                i++;
+            }
+        }
+
+        protected override void Subtract(decimal x, ReadOnlySpan<decimal> y, Span<decimal> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (decimal)(x - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<decimal> x, ReadOnlySpan<decimal> y, Span<decimal> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (decimal)(x[i] * y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<decimal> x, decimal y, Span<decimal> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (decimal)(x[i] * y);
+                i++;
+            }
+        }
+
+        protected override void Multiply(decimal x, ReadOnlySpan<decimal> y, Span<decimal> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (decimal)(x * y[i]);
+                i++;
+            }
+        }
+
+        protected override decimal Divide(decimal x, decimal y)
+        {
+            return (decimal)(x / y);
+        }
+
+        protected override void Divide(ReadOnlySpan<decimal> x, ReadOnlySpan<decimal> y, Span<decimal> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (decimal)(x[i] / y[i]);
+                i++;
+            }
+        }
+
+        protected override void Divide(ReadOnlySpan<decimal> x, decimal y, Span<decimal> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (decimal)(x[i] / y);
+                i++;
+            }
+        }
+
+        protected override void Divide(decimal x, ReadOnlySpan<decimal> y, Span<decimal> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (decimal)(x / y[i]);
+                i++;
+            }
+        }
+
+        protected override decimal Modulo(decimal x, decimal y)
+        {
+            return (decimal)(x % y);
+        }
+
+        protected override void Modulo(ReadOnlySpan<decimal> x, ReadOnlySpan<decimal> y, Span<decimal> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (decimal)(x[i] % y[i]);
+                i++;
+            }
+        }
+
+        protected override void Modulo(ReadOnlySpan<decimal> x, decimal y, Span<decimal> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (decimal)(x[i] % y);
+                i++;
+            }
+        }
+
+        protected override void Modulo(decimal x, ReadOnlySpan<decimal> y, Span<decimal> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (decimal)(x % y[i]);
+                i++;
+            }
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<decimal> x, ReadOnlySpan<decimal> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y[i]);
+            }
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<decimal> x, decimal y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<decimal> x, ReadOnlySpan<decimal> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y[i]);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<decimal> x, decimal y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<decimal> x, ReadOnlySpan<decimal> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<decimal> x, decimal y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<decimal> x, ReadOnlySpan<decimal> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<decimal> x, decimal y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<decimal> x, ReadOnlySpan<decimal> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<decimal> x, decimal y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<decimal> x, ReadOnlySpan<decimal> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<decimal> x, decimal y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y);
+            }
+        }
+    }
+    internal class DoubleArithmetic : Arithmetic<double>
+    {
+
+        protected override void Add(ReadOnlySpan<double> x, ReadOnlySpan<double> y, Span<double> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref double xRef = ref MemoryMarshal.GetReference(x);
+                ref double yRef = ref MemoryMarshal.GetReference(y);
+                ref double dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<double>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) + Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (double)(x[i] + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Add(ReadOnlySpan<double> x, double y, Span<double> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (double)(x[i] + y);
+                i++;
+            }
+        }
+
+        protected override void Add(double x, ReadOnlySpan<double> y, Span<double> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (double)(x + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<double> x, ReadOnlySpan<double> y, Span<double> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref double xRef = ref MemoryMarshal.GetReference(x);
+                ref double yRef = ref MemoryMarshal.GetReference(y);
+                ref double dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<double>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) - Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (double)(x[i] - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<double> x, double y, Span<double> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (double)(x[i] - y);
+                i++;
+            }
+        }
+
+        protected override void Subtract(double x, ReadOnlySpan<double> y, Span<double> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (double)(x - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<double> x, ReadOnlySpan<double> y, Span<double> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref double xRef = ref MemoryMarshal.GetReference(x);
+                ref double yRef = ref MemoryMarshal.GetReference(y);
+                ref double dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<double>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) * Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (double)(x[i] * y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<double> x, double y, Span<double> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (double)(x[i] * y);
+                i++;
+            }
+        }
+
+        protected override void Multiply(double x, ReadOnlySpan<double> y, Span<double> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (double)(x * y[i]);
+                i++;
+            }
+        }
+
+        protected override double Divide(double x, double y)
+        {
+            return (double)(x / y);
+        }
+
+        protected override void Divide(ReadOnlySpan<double> x, ReadOnlySpan<double> y, Span<double> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref double xRef = ref MemoryMarshal.GetReference(x);
+                ref double yRef = ref MemoryMarshal.GetReference(y);
+                ref double dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<double>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) / Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (double)(x[i] / y[i]);
+                i++;
+            }
+        }
+
+        protected override void Divide(ReadOnlySpan<double> x, double y, Span<double> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (double)(x[i] / y);
+                i++;
+            }
+        }
+
+        protected override void Divide(double x, ReadOnlySpan<double> y, Span<double> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (double)(x / y[i]);
+                i++;
+            }
+        }
+
+        protected override double Modulo(double x, double y)
+        {
+            return (double)(x % y);
+        }
+
+        protected override void Modulo(ReadOnlySpan<double> x, ReadOnlySpan<double> y, Span<double> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (double)(x[i] % y[i]);
+                i++;
+            }
+        }
+
+        protected override void Modulo(ReadOnlySpan<double> x, double y, Span<double> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (double)(x[i] % y);
+                i++;
+            }
+        }
+
+        protected override void Modulo(double x, ReadOnlySpan<double> y, Span<double> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (double)(x % y[i]);
+                i++;
+            }
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<double> x, ReadOnlySpan<double> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y[i]);
+            }
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<double> x, double y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<double> x, ReadOnlySpan<double> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y[i]);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<double> x, double y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<double> x, ReadOnlySpan<double> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<double> x, double y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<double> x, ReadOnlySpan<double> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<double> x, double y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<double> x, ReadOnlySpan<double> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<double> x, double y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<double> x, ReadOnlySpan<double> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<double> x, double y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y);
+            }
+        }
+    }
+    internal class FloatArithmetic : Arithmetic<float>
+    {
+
+        protected override void Add(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref float xRef = ref MemoryMarshal.GetReference(x);
+                ref float yRef = ref MemoryMarshal.GetReference(y);
+                ref float dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<float>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) + Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (float)(x[i] + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Add(ReadOnlySpan<float> x, float y, Span<float> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (float)(x[i] + y);
+                i++;
+            }
+        }
+
+        protected override void Add(float x, ReadOnlySpan<float> y, Span<float> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (float)(x + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref float xRef = ref MemoryMarshal.GetReference(x);
+                ref float yRef = ref MemoryMarshal.GetReference(y);
+                ref float dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<float>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) - Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (float)(x[i] - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<float> x, float y, Span<float> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (float)(x[i] - y);
+                i++;
+            }
+        }
+
+        protected override void Subtract(float x, ReadOnlySpan<float> y, Span<float> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (float)(x - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref float xRef = ref MemoryMarshal.GetReference(x);
+                ref float yRef = ref MemoryMarshal.GetReference(y);
+                ref float dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<float>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) * Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (float)(x[i] * y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<float> x, float y, Span<float> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (float)(x[i] * y);
+                i++;
+            }
+        }
+
+        protected override void Multiply(float x, ReadOnlySpan<float> y, Span<float> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (float)(x * y[i]);
+                i++;
+            }
+        }
+
+        protected override float Divide(float x, float y)
+        {
+            return (float)(x / y);
+        }
+
+        protected override void Divide(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref float xRef = ref MemoryMarshal.GetReference(x);
+                ref float yRef = ref MemoryMarshal.GetReference(y);
+                ref float dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<float>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) / Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (float)(x[i] / y[i]);
+                i++;
+            }
+        }
+
+        protected override void Divide(ReadOnlySpan<float> x, float y, Span<float> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (float)(x[i] / y);
+                i++;
+            }
+        }
+
+        protected override void Divide(float x, ReadOnlySpan<float> y, Span<float> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (float)(x / y[i]);
+                i++;
+            }
+        }
+
+        protected override float Modulo(float x, float y)
+        {
+            return (float)(x % y);
+        }
+
+        protected override void Modulo(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (float)(x[i] % y[i]);
+                i++;
+            }
+        }
+
+        protected override void Modulo(ReadOnlySpan<float> x, float y, Span<float> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (float)(x[i] % y);
+                i++;
+            }
+        }
+
+        protected override void Modulo(float x, ReadOnlySpan<float> y, Span<float> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (float)(x % y[i]);
+                i++;
+            }
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<float> x, ReadOnlySpan<float> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y[i]);
+            }
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<float> x, float y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<float> x, ReadOnlySpan<float> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y[i]);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<float> x, float y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<float> x, ReadOnlySpan<float> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<float> x, float y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<float> x, ReadOnlySpan<float> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<float> x, float y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<float> x, ReadOnlySpan<float> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<float> x, float y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<float> x, ReadOnlySpan<float> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<float> x, float y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y);
+            }
+        }
+    }
+    internal class IntArithmetic : Arithmetic<int>
+    {
+
+        protected override void Add(ReadOnlySpan<int> x, ReadOnlySpan<int> y, Span<int> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref int xRef = ref MemoryMarshal.GetReference(x);
+                ref int yRef = ref MemoryMarshal.GetReference(y);
+                ref int dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<int>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) + Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (int)(x[i] + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Add(ReadOnlySpan<int> x, int y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (int)(x[i] + y);
+                i++;
+            }
+        }
+
+        protected override void Add(int x, ReadOnlySpan<int> y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (int)(x + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<int> x, ReadOnlySpan<int> y, Span<int> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref int xRef = ref MemoryMarshal.GetReference(x);
+                ref int yRef = ref MemoryMarshal.GetReference(y);
+                ref int dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<int>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) - Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (int)(x[i] - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<int> x, int y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (int)(x[i] - y);
+                i++;
+            }
+        }
+
+        protected override void Subtract(int x, ReadOnlySpan<int> y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (int)(x - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<int> x, ReadOnlySpan<int> y, Span<int> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref int xRef = ref MemoryMarshal.GetReference(x);
+                ref int yRef = ref MemoryMarshal.GetReference(y);
+                ref int dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<int>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) * Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (int)(x[i] * y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<int> x, int y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (int)(x[i] * y);
+                i++;
+            }
+        }
+
+        protected override void Multiply(int x, ReadOnlySpan<int> y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (int)(x * y[i]);
+                i++;
+            }
+        }
+
+        protected override int Divide(int x, int y)
+        {
+            return (int)(x / y);
+        }
+
+        protected override void Divide(ReadOnlySpan<int> x, ReadOnlySpan<int> y, Span<int> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref int xRef = ref MemoryMarshal.GetReference(x);
+                ref int yRef = ref MemoryMarshal.GetReference(y);
+                ref int dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<int>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) / Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (int)(x[i] / y[i]);
+                i++;
+            }
+        }
+
+        protected override void Divide(ReadOnlySpan<int> x, int y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (int)(x[i] / y);
+                i++;
+            }
+        }
+
+        protected override void Divide(int x, ReadOnlySpan<int> y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (int)(x / y[i]);
+                i++;
+            }
+        }
+
+        protected override int Modulo(int x, int y)
+        {
+            return (int)(x % y);
+        }
+
+        protected override void Modulo(ReadOnlySpan<int> x, ReadOnlySpan<int> y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (int)(x[i] % y[i]);
+                i++;
+            }
+        }
+
+        protected override void Modulo(ReadOnlySpan<int> x, int y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (int)(x[i] % y);
+                i++;
+            }
+        }
+
+        protected override void Modulo(int x, ReadOnlySpan<int> y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (int)(x % y[i]);
+                i++;
+            }
+        }
+
+        protected override void And(ReadOnlySpan<int> x, ReadOnlySpan<int> y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (int)(x[i] & y[i]);
+                i++;
+            }
+        }
+
+        protected override void And(ReadOnlySpan<int> x, int y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (int)(x[i] & y);
+                i++;
+            }
+        }
+
+        protected override void And(int x, ReadOnlySpan<int> y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (int)(x & y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<int> x, ReadOnlySpan<int> y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (int)(x[i] | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<int> x, int y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (int)(x[i] | y);
+                i++;
+            }
+        }
+
+        protected override void Or(int x, ReadOnlySpan<int> y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (int)(x | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<int> x, ReadOnlySpan<int> y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (int)(x[i] ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<int> x, int y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (int)(x[i] ^ y);
+                i++;
+            }
+        }
+
+        protected override void Xor(int x, ReadOnlySpan<int> y, Span<int> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (int)(x ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void LeftShift(ReadOnlySpan<int> x, int y, Span<int> destination)
+        {
+            for (var i = 0; i < x.Length; i++)
+                destination[i] = (int)(x[i] << y);
+        }
+
+        protected override void RightShift(ReadOnlySpan<int> x, int y, Span<int> destination)
+        {
+            for (var i = 0; i < x.Length; i++)
+                destination[i] = (int)(x[i] >> y);
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<int> x, ReadOnlySpan<int> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y[i]);
+            }
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<int> x, int y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<int> x, ReadOnlySpan<int> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y[i]);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<int> x, int y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<int> x, ReadOnlySpan<int> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<int> x, int y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<int> x, ReadOnlySpan<int> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<int> x, int y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<int> x, ReadOnlySpan<int> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<int> x, int y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<int> x, ReadOnlySpan<int> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<int> x, int y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y);
+            }
+        }
+    }
+    internal class LongArithmetic : Arithmetic<long>
+    {
+
+        protected override void Add(ReadOnlySpan<long> x, ReadOnlySpan<long> y, Span<long> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref long xRef = ref MemoryMarshal.GetReference(x);
+                ref long yRef = ref MemoryMarshal.GetReference(y);
+                ref long dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<long>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) + Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (long)(x[i] + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Add(ReadOnlySpan<long> x, long y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (long)(x[i] + y);
+                i++;
+            }
+        }
+
+        protected override void Add(long x, ReadOnlySpan<long> y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (long)(x + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<long> x, ReadOnlySpan<long> y, Span<long> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref long xRef = ref MemoryMarshal.GetReference(x);
+                ref long yRef = ref MemoryMarshal.GetReference(y);
+                ref long dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<long>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) - Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (long)(x[i] - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<long> x, long y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (long)(x[i] - y);
+                i++;
+            }
+        }
+
+        protected override void Subtract(long x, ReadOnlySpan<long> y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (long)(x - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<long> x, ReadOnlySpan<long> y, Span<long> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref long xRef = ref MemoryMarshal.GetReference(x);
+                ref long yRef = ref MemoryMarshal.GetReference(y);
+                ref long dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<long>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) * Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (long)(x[i] * y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<long> x, long y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (long)(x[i] * y);
+                i++;
+            }
+        }
+
+        protected override void Multiply(long x, ReadOnlySpan<long> y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (long)(x * y[i]);
+                i++;
+            }
+        }
+
+        protected override long Divide(long x, long y)
+        {
+            return (long)(x / y);
+        }
+
+        protected override void Divide(ReadOnlySpan<long> x, ReadOnlySpan<long> y, Span<long> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref long xRef = ref MemoryMarshal.GetReference(x);
+                ref long yRef = ref MemoryMarshal.GetReference(y);
+                ref long dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<long>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) / Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (long)(x[i] / y[i]);
+                i++;
+            }
+        }
+
+        protected override void Divide(ReadOnlySpan<long> x, long y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (long)(x[i] / y);
+                i++;
+            }
+        }
+
+        protected override void Divide(long x, ReadOnlySpan<long> y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (long)(x / y[i]);
+                i++;
+            }
+        }
+
+        protected override long Modulo(long x, long y)
+        {
+            return (long)(x % y);
+        }
+
+        protected override void Modulo(ReadOnlySpan<long> x, ReadOnlySpan<long> y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (long)(x[i] % y[i]);
+                i++;
+            }
+        }
+
+        protected override void Modulo(ReadOnlySpan<long> x, long y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (long)(x[i] % y);
+                i++;
+            }
+        }
+
+        protected override void Modulo(long x, ReadOnlySpan<long> y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (long)(x % y[i]);
+                i++;
+            }
+        }
+
+        protected override void And(ReadOnlySpan<long> x, ReadOnlySpan<long> y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (long)(x[i] & y[i]);
+                i++;
+            }
+        }
+
+        protected override void And(ReadOnlySpan<long> x, long y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (long)(x[i] & y);
+                i++;
+            }
+        }
+
+        protected override void And(long x, ReadOnlySpan<long> y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (long)(x & y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<long> x, ReadOnlySpan<long> y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (long)(x[i] | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<long> x, long y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (long)(x[i] | y);
+                i++;
+            }
+        }
+
+        protected override void Or(long x, ReadOnlySpan<long> y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (long)(x | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<long> x, ReadOnlySpan<long> y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (long)(x[i] ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<long> x, long y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (long)(x[i] ^ y);
+                i++;
+            }
+        }
+
+        protected override void Xor(long x, ReadOnlySpan<long> y, Span<long> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (long)(x ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void LeftShift(ReadOnlySpan<long> x, int y, Span<long> destination)
+        {
+            for (var i = 0; i < x.Length; i++)
+                destination[i] = (long)(x[i] << y);
+        }
+
+        protected override void RightShift(ReadOnlySpan<long> x, int y, Span<long> destination)
+        {
+            for (var i = 0; i < x.Length; i++)
+                destination[i] = (long)(x[i] >> y);
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<long> x, ReadOnlySpan<long> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y[i]);
+            }
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<long> x, long y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<long> x, ReadOnlySpan<long> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y[i]);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<long> x, long y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<long> x, ReadOnlySpan<long> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<long> x, long y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<long> x, ReadOnlySpan<long> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<long> x, long y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<long> x, ReadOnlySpan<long> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<long> x, long y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<long> x, ReadOnlySpan<long> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<long> x, long y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y);
+            }
+        }
+    }
+    internal class SByteArithmetic : Arithmetic<sbyte>
+    {
+
+        protected override void Add(ReadOnlySpan<sbyte> x, ReadOnlySpan<sbyte> y, Span<sbyte> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref sbyte xRef = ref MemoryMarshal.GetReference(x);
+                ref sbyte yRef = ref MemoryMarshal.GetReference(y);
+                ref sbyte dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<sbyte>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) + Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (sbyte)(x[i] + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Add(ReadOnlySpan<sbyte> x, sbyte y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (sbyte)(x[i] + y);
+                i++;
+            }
+        }
+
+        protected override void Add(sbyte x, ReadOnlySpan<sbyte> y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (sbyte)(x + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<sbyte> x, ReadOnlySpan<sbyte> y, Span<sbyte> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref sbyte xRef = ref MemoryMarshal.GetReference(x);
+                ref sbyte yRef = ref MemoryMarshal.GetReference(y);
+                ref sbyte dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<sbyte>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) - Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (sbyte)(x[i] - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<sbyte> x, sbyte y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (sbyte)(x[i] - y);
+                i++;
+            }
+        }
+
+        protected override void Subtract(sbyte x, ReadOnlySpan<sbyte> y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (sbyte)(x - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<sbyte> x, ReadOnlySpan<sbyte> y, Span<sbyte> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref sbyte xRef = ref MemoryMarshal.GetReference(x);
+                ref sbyte yRef = ref MemoryMarshal.GetReference(y);
+                ref sbyte dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<sbyte>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) * Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (sbyte)(x[i] * y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<sbyte> x, sbyte y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (sbyte)(x[i] * y);
+                i++;
+            }
+        }
+
+        protected override void Multiply(sbyte x, ReadOnlySpan<sbyte> y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (sbyte)(x * y[i]);
+                i++;
+            }
+        }
+
+        protected override sbyte Divide(sbyte x, sbyte y)
+        {
+            return (sbyte)(x / y);
+        }
+
+        protected override void Divide(ReadOnlySpan<sbyte> x, ReadOnlySpan<sbyte> y, Span<sbyte> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref sbyte xRef = ref MemoryMarshal.GetReference(x);
+                ref sbyte yRef = ref MemoryMarshal.GetReference(y);
+                ref sbyte dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<sbyte>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) / Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (sbyte)(x[i] / y[i]);
+                i++;
+            }
+        }
+
+        protected override void Divide(ReadOnlySpan<sbyte> x, sbyte y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (sbyte)(x[i] / y);
+                i++;
+            }
+        }
+
+        protected override void Divide(sbyte x, ReadOnlySpan<sbyte> y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (sbyte)(x / y[i]);
+                i++;
+            }
+        }
+
+        protected override sbyte Modulo(sbyte x, sbyte y)
+        {
+            return (sbyte)(x % y);
+        }
+
+        protected override void Modulo(ReadOnlySpan<sbyte> x, ReadOnlySpan<sbyte> y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (sbyte)(x[i] % y[i]);
+                i++;
+            }
+        }
+
+        protected override void Modulo(ReadOnlySpan<sbyte> x, sbyte y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (sbyte)(x[i] % y);
+                i++;
+            }
+        }
+
+        protected override void Modulo(sbyte x, ReadOnlySpan<sbyte> y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (sbyte)(x % y[i]);
+                i++;
+            }
+        }
+
+        protected override void And(ReadOnlySpan<sbyte> x, ReadOnlySpan<sbyte> y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (sbyte)(x[i] & y[i]);
+                i++;
+            }
+        }
+
+        protected override void And(ReadOnlySpan<sbyte> x, sbyte y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (sbyte)(x[i] & y);
+                i++;
+            }
+        }
+
+        protected override void And(sbyte x, ReadOnlySpan<sbyte> y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (sbyte)(x & y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<sbyte> x, ReadOnlySpan<sbyte> y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (sbyte)(x[i] | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<sbyte> x, sbyte y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (sbyte)(x[i] | y);
+                i++;
+            }
+        }
+
+        protected override void Or(sbyte x, ReadOnlySpan<sbyte> y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (sbyte)(x | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<sbyte> x, ReadOnlySpan<sbyte> y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (sbyte)(x[i] ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<sbyte> x, sbyte y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (sbyte)(x[i] ^ y);
+                i++;
+            }
+        }
+
+        protected override void Xor(sbyte x, ReadOnlySpan<sbyte> y, Span<sbyte> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (sbyte)(x ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void LeftShift(ReadOnlySpan<sbyte> x, int y, Span<sbyte> destination)
+        {
+            for (var i = 0; i < x.Length; i++)
+                destination[i] = (sbyte)(x[i] << y);
+        }
+
+        protected override void RightShift(ReadOnlySpan<sbyte> x, int y, Span<sbyte> destination)
+        {
+            for (var i = 0; i < x.Length; i++)
+                destination[i] = (sbyte)(x[i] >> y);
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<sbyte> x, ReadOnlySpan<sbyte> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y[i]);
+            }
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<sbyte> x, sbyte y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<sbyte> x, ReadOnlySpan<sbyte> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y[i]);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<sbyte> x, sbyte y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<sbyte> x, ReadOnlySpan<sbyte> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<sbyte> x, sbyte y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<sbyte> x, ReadOnlySpan<sbyte> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<sbyte> x, sbyte y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<sbyte> x, ReadOnlySpan<sbyte> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<sbyte> x, sbyte y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<sbyte> x, ReadOnlySpan<sbyte> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<sbyte> x, sbyte y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y);
+            }
+        }
+    }
+    internal class ShortArithmetic : Arithmetic<short>
+    {
+
+        protected override void Add(ReadOnlySpan<short> x, ReadOnlySpan<short> y, Span<short> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref short xRef = ref MemoryMarshal.GetReference(x);
+                ref short yRef = ref MemoryMarshal.GetReference(y);
+                ref short dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<short>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) + Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (short)(x[i] + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Add(ReadOnlySpan<short> x, short y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (short)(x[i] + y);
+                i++;
+            }
+        }
+
+        protected override void Add(short x, ReadOnlySpan<short> y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (short)(x + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<short> x, ReadOnlySpan<short> y, Span<short> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref short xRef = ref MemoryMarshal.GetReference(x);
+                ref short yRef = ref MemoryMarshal.GetReference(y);
+                ref short dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<short>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) - Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (short)(x[i] - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<short> x, short y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (short)(x[i] - y);
+                i++;
+            }
+        }
+
+        protected override void Subtract(short x, ReadOnlySpan<short> y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (short)(x - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<short> x, ReadOnlySpan<short> y, Span<short> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref short xRef = ref MemoryMarshal.GetReference(x);
+                ref short yRef = ref MemoryMarshal.GetReference(y);
+                ref short dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<short>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) * Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (short)(x[i] * y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<short> x, short y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (short)(x[i] * y);
+                i++;
+            }
+        }
+
+        protected override void Multiply(short x, ReadOnlySpan<short> y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (short)(x * y[i]);
+                i++;
+            }
+        }
+
+        protected override short Divide(short x, short y)
+        {
+            return (short)(x / y);
+        }
+
+        protected override void Divide(ReadOnlySpan<short> x, ReadOnlySpan<short> y, Span<short> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref short xRef = ref MemoryMarshal.GetReference(x);
+                ref short yRef = ref MemoryMarshal.GetReference(y);
+                ref short dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<short>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) / Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (short)(x[i] / y[i]);
+                i++;
+            }
+        }
+
+        protected override void Divide(ReadOnlySpan<short> x, short y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (short)(x[i] / y);
+                i++;
+            }
+        }
+
+        protected override void Divide(short x, ReadOnlySpan<short> y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (short)(x / y[i]);
+                i++;
+            }
+        }
+
+        protected override short Modulo(short x, short y)
+        {
+            return (short)(x % y);
+        }
+
+        protected override void Modulo(ReadOnlySpan<short> x, ReadOnlySpan<short> y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (short)(x[i] % y[i]);
+                i++;
+            }
+        }
+
+        protected override void Modulo(ReadOnlySpan<short> x, short y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (short)(x[i] % y);
+                i++;
+            }
+        }
+
+        protected override void Modulo(short x, ReadOnlySpan<short> y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (short)(x % y[i]);
+                i++;
+            }
+        }
+
+        protected override void And(ReadOnlySpan<short> x, ReadOnlySpan<short> y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (short)(x[i] & y[i]);
+                i++;
+            }
+        }
+
+        protected override void And(ReadOnlySpan<short> x, short y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (short)(x[i] & y);
+                i++;
+            }
+        }
+
+        protected override void And(short x, ReadOnlySpan<short> y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (short)(x & y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<short> x, ReadOnlySpan<short> y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (short)(x[i] | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<short> x, short y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (short)(x[i] | y);
+                i++;
+            }
+        }
+
+        protected override void Or(short x, ReadOnlySpan<short> y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (short)(x | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<short> x, ReadOnlySpan<short> y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (short)(x[i] ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<short> x, short y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (short)(x[i] ^ y);
+                i++;
+            }
+        }
+
+        protected override void Xor(short x, ReadOnlySpan<short> y, Span<short> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (short)(x ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void LeftShift(ReadOnlySpan<short> x, int y, Span<short> destination)
+        {
+            for (var i = 0; i < x.Length; i++)
+                destination[i] = (short)(x[i] << y);
+        }
+
+        protected override void RightShift(ReadOnlySpan<short> x, int y, Span<short> destination)
+        {
+            for (var i = 0; i < x.Length; i++)
+                destination[i] = (short)(x[i] >> y);
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<short> x, ReadOnlySpan<short> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y[i]);
+            }
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<short> x, short y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<short> x, ReadOnlySpan<short> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y[i]);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<short> x, short y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<short> x, ReadOnlySpan<short> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<short> x, short y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<short> x, ReadOnlySpan<short> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<short> x, short y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<short> x, ReadOnlySpan<short> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<short> x, short y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<short> x, ReadOnlySpan<short> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<short> x, short y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y);
+            }
+        }
+    }
+    internal class UIntArithmetic : Arithmetic<uint>
+    {
+
+        protected override void Add(ReadOnlySpan<uint> x, ReadOnlySpan<uint> y, Span<uint> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref uint xRef = ref MemoryMarshal.GetReference(x);
+                ref uint yRef = ref MemoryMarshal.GetReference(y);
+                ref uint dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<uint>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) + Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (uint)(x[i] + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Add(ReadOnlySpan<uint> x, uint y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (uint)(x[i] + y);
+                i++;
+            }
+        }
+
+        protected override void Add(uint x, ReadOnlySpan<uint> y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (uint)(x + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<uint> x, ReadOnlySpan<uint> y, Span<uint> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref uint xRef = ref MemoryMarshal.GetReference(x);
+                ref uint yRef = ref MemoryMarshal.GetReference(y);
+                ref uint dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<uint>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) - Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (uint)(x[i] - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<uint> x, uint y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (uint)(x[i] - y);
+                i++;
+            }
+        }
+
+        protected override void Subtract(uint x, ReadOnlySpan<uint> y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (uint)(x - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<uint> x, ReadOnlySpan<uint> y, Span<uint> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref uint xRef = ref MemoryMarshal.GetReference(x);
+                ref uint yRef = ref MemoryMarshal.GetReference(y);
+                ref uint dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<uint>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) * Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (uint)(x[i] * y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<uint> x, uint y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (uint)(x[i] * y);
+                i++;
+            }
+        }
+
+        protected override void Multiply(uint x, ReadOnlySpan<uint> y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (uint)(x * y[i]);
+                i++;
+            }
+        }
+
+        protected override uint Divide(uint x, uint y)
+        {
+            return (uint)(x / y);
+        }
+
+        protected override void Divide(ReadOnlySpan<uint> x, ReadOnlySpan<uint> y, Span<uint> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref uint xRef = ref MemoryMarshal.GetReference(x);
+                ref uint yRef = ref MemoryMarshal.GetReference(y);
+                ref uint dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<uint>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) / Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (uint)(x[i] / y[i]);
+                i++;
+            }
+        }
+
+        protected override void Divide(ReadOnlySpan<uint> x, uint y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (uint)(x[i] / y);
+                i++;
+            }
+        }
+
+        protected override void Divide(uint x, ReadOnlySpan<uint> y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (uint)(x / y[i]);
+                i++;
+            }
+        }
+
+        protected override uint Modulo(uint x, uint y)
+        {
+            return (uint)(x % y);
+        }
+
+        protected override void Modulo(ReadOnlySpan<uint> x, ReadOnlySpan<uint> y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (uint)(x[i] % y[i]);
+                i++;
+            }
+        }
+
+        protected override void Modulo(ReadOnlySpan<uint> x, uint y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (uint)(x[i] % y);
+                i++;
+            }
+        }
+
+        protected override void Modulo(uint x, ReadOnlySpan<uint> y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (uint)(x % y[i]);
+                i++;
+            }
+        }
+
+        protected override void And(ReadOnlySpan<uint> x, ReadOnlySpan<uint> y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (uint)(x[i] & y[i]);
+                i++;
+            }
+        }
+
+        protected override void And(ReadOnlySpan<uint> x, uint y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (uint)(x[i] & y);
+                i++;
+            }
+        }
+
+        protected override void And(uint x, ReadOnlySpan<uint> y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (uint)(x & y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<uint> x, ReadOnlySpan<uint> y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (uint)(x[i] | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<uint> x, uint y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (uint)(x[i] | y);
+                i++;
+            }
+        }
+
+        protected override void Or(uint x, ReadOnlySpan<uint> y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (uint)(x | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<uint> x, ReadOnlySpan<uint> y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (uint)(x[i] ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<uint> x, uint y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (uint)(x[i] ^ y);
+                i++;
+            }
+        }
+
+        protected override void Xor(uint x, ReadOnlySpan<uint> y, Span<uint> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (uint)(x ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void LeftShift(ReadOnlySpan<uint> x, int y, Span<uint> destination)
+        {
+            for (var i = 0; i < x.Length; i++)
+                destination[i] = (uint)(x[i] << y);
+        }
+
+        protected override void RightShift(ReadOnlySpan<uint> x, int y, Span<uint> destination)
+        {
+            for (var i = 0; i < x.Length; i++)
+                destination[i] = (uint)(x[i] >> y);
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<uint> x, ReadOnlySpan<uint> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y[i]);
+            }
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<uint> x, uint y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<uint> x, ReadOnlySpan<uint> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y[i]);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<uint> x, uint y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<uint> x, ReadOnlySpan<uint> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<uint> x, uint y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<uint> x, ReadOnlySpan<uint> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<uint> x, uint y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<uint> x, ReadOnlySpan<uint> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<uint> x, uint y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<uint> x, ReadOnlySpan<uint> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<uint> x, uint y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y);
+            }
+        }
+    }
+    internal class ULongArithmetic : Arithmetic<ulong>
+    {
+
+        protected override void Add(ReadOnlySpan<ulong> x, ReadOnlySpan<ulong> y, Span<ulong> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref ulong xRef = ref MemoryMarshal.GetReference(x);
+                ref ulong yRef = ref MemoryMarshal.GetReference(y);
+                ref ulong dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<ulong>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) + Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (ulong)(x[i] + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Add(ReadOnlySpan<ulong> x, ulong y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ulong)(x[i] + y);
+                i++;
+            }
+        }
+
+        protected override void Add(ulong x, ReadOnlySpan<ulong> y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (ulong)(x + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<ulong> x, ReadOnlySpan<ulong> y, Span<ulong> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref ulong xRef = ref MemoryMarshal.GetReference(x);
+                ref ulong yRef = ref MemoryMarshal.GetReference(y);
+                ref ulong dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<ulong>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) - Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (ulong)(x[i] - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<ulong> x, ulong y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ulong)(x[i] - y);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ulong x, ReadOnlySpan<ulong> y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (ulong)(x - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<ulong> x, ReadOnlySpan<ulong> y, Span<ulong> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref ulong xRef = ref MemoryMarshal.GetReference(x);
+                ref ulong yRef = ref MemoryMarshal.GetReference(y);
+                ref ulong dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<ulong>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) * Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (ulong)(x[i] * y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<ulong> x, ulong y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ulong)(x[i] * y);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ulong x, ReadOnlySpan<ulong> y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (ulong)(x * y[i]);
+                i++;
+            }
+        }
+
+        protected override ulong Divide(ulong x, ulong y)
+        {
+            return (ulong)(x / y);
+        }
+
+        protected override void Divide(ReadOnlySpan<ulong> x, ReadOnlySpan<ulong> y, Span<ulong> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref ulong xRef = ref MemoryMarshal.GetReference(x);
+                ref ulong yRef = ref MemoryMarshal.GetReference(y);
+                ref ulong dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<ulong>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) / Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (ulong)(x[i] / y[i]);
+                i++;
+            }
+        }
+
+        protected override void Divide(ReadOnlySpan<ulong> x, ulong y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ulong)(x[i] / y);
+                i++;
+            }
+        }
+
+        protected override void Divide(ulong x, ReadOnlySpan<ulong> y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (ulong)(x / y[i]);
+                i++;
+            }
+        }
+
+        protected override ulong Modulo(ulong x, ulong y)
+        {
+            return (ulong)(x % y);
+        }
+
+        protected override void Modulo(ReadOnlySpan<ulong> x, ReadOnlySpan<ulong> y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ulong)(x[i] % y[i]);
+                i++;
+            }
+        }
+
+        protected override void Modulo(ReadOnlySpan<ulong> x, ulong y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ulong)(x[i] % y);
+                i++;
+            }
+        }
+
+        protected override void Modulo(ulong x, ReadOnlySpan<ulong> y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (ulong)(x % y[i]);
+                i++;
+            }
+        }
+
+        protected override void And(ReadOnlySpan<ulong> x, ReadOnlySpan<ulong> y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ulong)(x[i] & y[i]);
+                i++;
+            }
+        }
+
+        protected override void And(ReadOnlySpan<ulong> x, ulong y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ulong)(x[i] & y);
+                i++;
+            }
+        }
+
+        protected override void And(ulong x, ReadOnlySpan<ulong> y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (ulong)(x & y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<ulong> x, ReadOnlySpan<ulong> y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ulong)(x[i] | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<ulong> x, ulong y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ulong)(x[i] | y);
+                i++;
+            }
+        }
+
+        protected override void Or(ulong x, ReadOnlySpan<ulong> y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (ulong)(x | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<ulong> x, ReadOnlySpan<ulong> y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ulong)(x[i] ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<ulong> x, ulong y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ulong)(x[i] ^ y);
+                i++;
+            }
+        }
+
+        protected override void Xor(ulong x, ReadOnlySpan<ulong> y, Span<ulong> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (ulong)(x ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void LeftShift(ReadOnlySpan<ulong> x, int y, Span<ulong> destination)
+        {
+            for (var i = 0; i < x.Length; i++)
+                destination[i] = (ulong)(x[i] << y);
+        }
+
+        protected override void RightShift(ReadOnlySpan<ulong> x, int y, Span<ulong> destination)
+        {
+            for (var i = 0; i < x.Length; i++)
+                destination[i] = (ulong)(x[i] >> y);
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<ulong> x, ReadOnlySpan<ulong> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y[i]);
+            }
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<ulong> x, ulong y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<ulong> x, ReadOnlySpan<ulong> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y[i]);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<ulong> x, ulong y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<ulong> x, ReadOnlySpan<ulong> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<ulong> x, ulong y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<ulong> x, ReadOnlySpan<ulong> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<ulong> x, ulong y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<ulong> x, ReadOnlySpan<ulong> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<ulong> x, ulong y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<ulong> x, ReadOnlySpan<ulong> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<ulong> x, ulong y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y);
+            }
+        }
+    }
+    internal class UShortArithmetic : Arithmetic<ushort>
+    {
+
+        protected override void Add(ReadOnlySpan<ushort> x, ReadOnlySpan<ushort> y, Span<ushort> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref ushort xRef = ref MemoryMarshal.GetReference(x);
+                ref ushort yRef = ref MemoryMarshal.GetReference(y);
+                ref ushort dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<ushort>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) + Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (ushort)(x[i] + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Add(ReadOnlySpan<ushort> x, ushort y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ushort)(x[i] + y);
+                i++;
+            }
+        }
+
+        protected override void Add(ushort x, ReadOnlySpan<ushort> y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (ushort)(x + y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<ushort> x, ReadOnlySpan<ushort> y, Span<ushort> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref ushort xRef = ref MemoryMarshal.GetReference(x);
+                ref ushort yRef = ref MemoryMarshal.GetReference(y);
+                ref ushort dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<ushort>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) - Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (ushort)(x[i] - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ReadOnlySpan<ushort> x, ushort y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ushort)(x[i] - y);
+                i++;
+            }
+        }
+
+        protected override void Subtract(ushort x, ReadOnlySpan<ushort> y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (ushort)(x - y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<ushort> x, ReadOnlySpan<ushort> y, Span<ushort> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref ushort xRef = ref MemoryMarshal.GetReference(x);
+                ref ushort yRef = ref MemoryMarshal.GetReference(y);
+                ref ushort dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<ushort>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) * Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (ushort)(x[i] * y[i]);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ReadOnlySpan<ushort> x, ushort y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ushort)(x[i] * y);
+                i++;
+            }
+        }
+
+        protected override void Multiply(ushort x, ReadOnlySpan<ushort> y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (ushort)(x * y[i]);
+                i++;
+            }
+        }
+
+        protected override ushort Divide(ushort x, ushort y)
+        {
+            return (ushort)(x / y);
+        }
+
+        protected override void Divide(ReadOnlySpan<ushort> x, ReadOnlySpan<ushort> y, Span<ushort> destination)
+        {
+            int i = 0;
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref ushort xRef = ref MemoryMarshal.GetReference(x);
+                ref ushort yRef = ref MemoryMarshal.GetReference(y);
+                ref ushort dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<ushort>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) / Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+
+            while (i < x.Length)
+            {
+                destination[i] = (ushort)(x[i] / y[i]);
+                i++;
+            }
+        }
+
+        protected override void Divide(ReadOnlySpan<ushort> x, ushort y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ushort)(x[i] / y);
+                i++;
+            }
+        }
+
+        protected override void Divide(ushort x, ReadOnlySpan<ushort> y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (ushort)(x / y[i]);
+                i++;
+            }
+        }
+
+        protected override ushort Modulo(ushort x, ushort y)
+        {
+            return (ushort)(x % y);
+        }
+
+        protected override void Modulo(ReadOnlySpan<ushort> x, ReadOnlySpan<ushort> y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ushort)(x[i] % y[i]);
+                i++;
+            }
+        }
+
+        protected override void Modulo(ReadOnlySpan<ushort> x, ushort y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ushort)(x[i] % y);
+                i++;
+            }
+        }
+
+        protected override void Modulo(ushort x, ReadOnlySpan<ushort> y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (ushort)(x % y[i]);
+                i++;
+            }
+        }
+
+        protected override void And(ReadOnlySpan<ushort> x, ReadOnlySpan<ushort> y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ushort)(x[i] & y[i]);
+                i++;
+            }
+        }
+
+        protected override void And(ReadOnlySpan<ushort> x, ushort y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ushort)(x[i] & y);
+                i++;
+            }
+        }
+
+        protected override void And(ushort x, ReadOnlySpan<ushort> y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (ushort)(x & y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<ushort> x, ReadOnlySpan<ushort> y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ushort)(x[i] | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Or(ReadOnlySpan<ushort> x, ushort y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ushort)(x[i] | y);
+                i++;
+            }
+        }
+
+        protected override void Or(ushort x, ReadOnlySpan<ushort> y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (ushort)(x | y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<ushort> x, ReadOnlySpan<ushort> y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ushort)(x[i] ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void Xor(ReadOnlySpan<ushort> x, ushort y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < x.Length)
+            {
+                destination[i] = (ushort)(x[i] ^ y);
+                i++;
+            }
+        }
+
+        protected override void Xor(ushort x, ReadOnlySpan<ushort> y, Span<ushort> destination)
+        {
+            int i = 0;
+
+            while (i < y.Length)
+            {
+                destination[i] = (ushort)(x ^ y[i]);
+                i++;
+            }
+        }
+
+        protected override void LeftShift(ReadOnlySpan<ushort> x, int y, Span<ushort> destination)
+        {
+            for (var i = 0; i < x.Length; i++)
+                destination[i] = (ushort)(x[i] << y);
+        }
+
+        protected override void RightShift(ReadOnlySpan<ushort> x, int y, Span<ushort> destination)
+        {
+            for (var i = 0; i < x.Length; i++)
+                destination[i] = (ushort)(x[i] >> y);
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<ushort> x, ReadOnlySpan<ushort> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y[i]);
+            }
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<ushort> x, ushort y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<ushort> x, ReadOnlySpan<ushort> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y[i]);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<ushort> x, ushort y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<ushort> x, ReadOnlySpan<ushort> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<ushort> x, ushort y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] >= y);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<ushort> x, ReadOnlySpan<ushort> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<ushort> x, ushort y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <= y);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<ushort> x, ReadOnlySpan<ushort> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y[i]);
+            }
+        }
+
+        protected override void ElementwiseGreaterThan(ReadOnlySpan<ushort> x, ushort y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] > y);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<ushort> x, ReadOnlySpan<ushort> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y[i]);
+            }
+        }
+
+        protected override void ElementwiseLessThan(ReadOnlySpan<ushort> x, ushort y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] < y);
+            }
+        }
+    }
+    internal class DateTimeArithmetic : Arithmetic<DateTime>
+    {
+
+        protected override void ElementwiseEquals(ReadOnlySpan<DateTime> x, ReadOnlySpan<DateTime> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y[i]);
+            }
+        }
+
+        protected override void ElementwiseEquals(ReadOnlySpan<DateTime> x, DateTime y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] == y);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<DateTime> x, ReadOnlySpan<DateTime> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y[i]);
+            }
+        }
+
+        protected override void ElementwiseNotEquals(ReadOnlySpan<DateTime> x, DateTime y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] != y);
+            }
+        }
+    }
+}
diff --git a/src/Microsoft.Data.Analysis/Computations/Arithmetics.tt b/src/Microsoft.Data.Analysis/Computations/Arithmetics.tt
new file mode 100644
index 0000000000..200739953a
--- /dev/null
+++ b/src/Microsoft.Data.Analysis/Computations/Arithmetics.tt
@@ -0,0 +1,171 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ assembly name="System" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ output extension=".cs" #>
+<#@ include file="$(ProjectDir)\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 Arithmetics.tt. Do not modify directly
+
+using System;
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Data.Analysis
+{
+<# foreach (TypeConfiguration type in typeConfiguration) { #>
+    internal class <#=type.ClassPrefix#>Arithmetic : Arithmetic<<#=type.TypeName#>>
+    {
+<# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (!((method.IsNumeric && !type.SupportsNumeric) || (method.IsBitwise && !type.SupportsBitwise) || (type.UnsupportedMethods.Contains(method.MethodName))) && method.Operator != null) { #>
+<# if (method.MethodType == MethodType.Comparison) { #>
+
+        protected override void <#=method.MethodName#>(ReadOnlySpan<<#=type.TypeName#>> x, ReadOnlySpan<<#=type.TypeName#>> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <#= method.Operator #> y[i]);
+            }
+        }
+<# } else if (method.MethodType == MethodType.ComparisonScalar) {#>
+
+        protected override void <#=method.MethodName#>(ReadOnlySpan<<#=type.TypeName#>> x, <#=type.TypeName#> y, PrimitiveColumnContainer<bool> result, long offset)
+        {
+            for (var i = 0; i < x.Length; i++)
+            {
+                result[i + offset] = (x[i] <#= method.Operator #> y);
+            }
+        }
+<# } else if (method.MethodType == MethodType.Binary) { #>
+<# if (method.MethodName == "Divide" || method.MethodName == "Modulo") { #>
+
+        protected override <#=type.TypeName#> <#=method.MethodName#>(<#=type.TypeName#> x, <#=type.TypeName#> y)
+        {
+            return (<#=type.TypeName#>)(x <#= method.Operator #> y);
+        }
+<# } #>
+
+        protected override void <#=method.MethodName#>(ReadOnlySpan<<#=type.TypeName#>> x, ReadOnlySpan<<#=type.TypeName#>> y, Span<<#=type.TypeName#>> destination)
+        {
+            int i = 0;
+<# if (method.SupportsVectorization && type.SupportsVectorization) { #>
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref <#=type.TypeName#> xRef = ref MemoryMarshal.GetReference(x);
+                ref <#=type.TypeName#> yRef = ref MemoryMarshal.GetReference(y);
+                ref <#=type.TypeName#> dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<<#=type.TypeName#>>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) <#= method.Operator #> Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+<# } #>
+
+            while (i < x.Length)
+            {
+                destination[i] = (<#=type.TypeName#>)(x[i] <#= method.Operator #> y[i]);
+                i++;
+            }
+        }
+<# } #>
+<# else if (method.MethodType == MethodType.BinaryScalar) { #>
+
+        protected override void <#=method.MethodName#>(ReadOnlySpan<<#=type.TypeName#>> x, <#=type.TypeName#> y, Span<<#=type.TypeName#>> destination)
+        {
+            int i = 0;
+<# if (method.SupportsVectorization && type.SupportsVectorization) { #>
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref <#=type.TypeName#> xRef = ref MemoryMarshal.GetReference(x);
+                ref <#=type.TypeName#> dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<<#=type.TypeName#>>.Count;
+                var oneVectorFromEnd = x.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    Vector<<#=type.TypeName#>> yVec = new(y);
+
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (Arithmetic.AsVector(ref xRef, i) <#= method.Operator #>  yVec);
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+<# } #>
+
+            while (i < x.Length)
+            {
+                destination[i] = (<#=type.TypeName#>)(x[i] <#= method.Operator #> y);
+                i++;
+            }
+        }
+
+        protected override void <#=method.MethodName#>(<#=type.TypeName#> x, ReadOnlySpan<<#=type.TypeName#>> y, Span<<#=type.TypeName#>> destination)
+        {
+            int i = 0;
+<# if (method.SupportsVectorization && type.SupportsVectorization) { #>
+            if (Vector.IsHardwareAccelerated)
+            {
+                ref <#=type.TypeName#> yRef = ref MemoryMarshal.GetReference(y);
+                ref <#=type.TypeName#> dRef = ref MemoryMarshal.GetReference(destination);
+
+                var vectorSize = Vector<<#=type.TypeName#>>.Count;
+                var oneVectorFromEnd = y.Length - vectorSize;
+
+                if (oneVectorFromEnd >= 0)
+                {
+                    Vector<<#=type.TypeName#>> xVec = new(x);
+
+                    // Loop handling one vector at a time.
+                    do
+                    {
+                        Arithmetic.AsVector(ref dRef, i) = (xVec <#= method.Operator #>  Arithmetic.AsVector(ref yRef, i));
+
+                        i += vectorSize;
+                    }
+                    while (i <= oneVectorFromEnd);
+                }
+            }
+<# } #>
+
+            while (i < y.Length)
+            {
+                destination[i] = (<#=type.TypeName#>)(x <#= method.Operator #> y[i]);
+                i++;
+            }
+        }
+<# } #>
+<# else if (method.MethodType == MethodType.BinaryInt) { #>
+
+        protected override void <#=method.MethodName#>(ReadOnlySpan<<#=type.TypeName#>> x, int y, Span<<#=type.TypeName#>> destination)
+        {
+            for (var i = 0; i < x.Length; i++)
+                destination[i] = (<#=type.TypeName#>)(x[i] <#= method.Operator #> y);
+        }
+<# } #>
+<# } #>
+<# } #>
+    }
+<# } #>
+}
diff --git a/src/Microsoft.Data.Analysis/Computations/IArithmetic.cs b/src/Microsoft.Data.Analysis/Computations/IArithmetic.cs
new file mode 100644
index 0000000000..8d3342462d
--- /dev/null
+++ b/src/Microsoft.Data.Analysis/Computations/IArithmetic.cs
@@ -0,0 +1,28 @@
+// 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 IArithmetic<T>
+        where T : unmanaged
+    {
+        //Binary operations
+        void HandleOperation(BinaryOperation operation, ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination);
+        void HandleOperation(BinaryOperation operation, ReadOnlySpan<T> x, T y, Span<T> destination);
+        void HandleOperation(BinaryOperation operation, T x, ReadOnlySpan<T> y, Span<T> destination);
+
+        T HandleOperation(BinaryOperation operation, T x, T y);
+
+        //Binary Int operations
+        void HandleOperation(BinaryIntOperation operation, ReadOnlySpan<T> x, int y, Span<T> destination);
+
+        //Comparison operations
+        void HandleOperation(ComparisonOperation operation, ReadOnlySpan<T> x, ReadOnlySpan<T> y, PrimitiveColumnContainer<bool> destination, long offset);
+        void HandleOperation(ComparisonOperation operation, ReadOnlySpan<T> x, T y, PrimitiveColumnContainer<bool> destination, long offset);
+    }
+}
diff --git a/src/Microsoft.Data.Analysis/IPrimitiveDataFrameColumnArithmetic.cs b/src/Microsoft.Data.Analysis/IPrimitiveDataFrameColumnArithmetic.cs
deleted file mode 100644
index 780c2000e8..0000000000
--- a/src/Microsoft.Data.Analysis/IPrimitiveDataFrameColumnArithmetic.cs
+++ /dev/null
@@ -1,24 +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.
-
-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 ed9f74ce97..4b4fda6652 100644
--- a/src/Microsoft.Data.Analysis/Microsoft.Data.Analysis.csproj
+++ b/src/Microsoft.Data.Analysis/Microsoft.Data.Analysis.csproj
@@ -58,6 +58,10 @@
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>ColumnArithmetic.OperationEnums.cs</LastGenOutput>
     </None>
+    <None Update="Computations\Arithmetic.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>Arithmetic.cs</LastGenOutput>
+    </None>
     <None Update="Converters.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>Converters.cs</LastGenOutput>
@@ -115,7 +119,7 @@
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>PrimitiveDataFrameColumn.Computations.cs</LastGenOutput>
     </None>
-    <None Update="PrimitiveDataFrameColumnArithmetic.tt">
+    <None Update="Computations\Arithmetics.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>PrimitiveColumnArithmetic.cs</LastGenOutput>
     </None>
@@ -123,9 +127,9 @@
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>PrimitiveDataFrameColumnComputations.cs</LastGenOutput>
     </None>
-    <None Update="PrimitiveDataFrameColumnArithmetic.tt">
+    <None Update="Computations\Arithmetics.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
-      <LastGenOutput>PrimitiveDataFrameColumnArithmetic.cs</LastGenOutput>
+      <LastGenOutput>Arithmetics.cs</LastGenOutput>
     </None>
   </ItemGroup>
 
@@ -134,6 +138,11 @@
   </ItemGroup>
 
   <ItemGroup>
+    <Compile Update="Computations\Arithmetic.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Arithmetic.tt</DependentUpon>
+    </Compile>
     <Compile Update="Converters.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
@@ -199,7 +208,7 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>PrimitiveDataFrameColumn.Computations.tt</DependentUpon>
     </Compile>
-    <Compile Update="PrimitiveDataFrameColumnArithmetic.cs">
+    <Compile Update="Computations\Arithmetics.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
       <DependentUpon>PrimitiveColumnArithmetic.tt</DependentUpon>
@@ -209,10 +218,10 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>PrimitiveDataFrameColumnComputations.tt</DependentUpon>
     </Compile>
-    <Compile Update="PrimitiveDataFrameColumnArithmetic.cs">
+    <Compile Update="Computations\Arithmetics.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
-      <DependentUpon>PrimitiveDataFrameColumnArithmetic.tt</DependentUpon>
+      <DependentUpon>Arithmetics.tt</DependentUpon>
     </Compile>
     <Compile Update="Strings.Designer.cs">
       <DesignTime>True</DesignTime>
diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs
index 58180924a8..37589b9d3f 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs
@@ -11,8 +11,12 @@ internal partial class PrimitiveColumnContainer<T>
     {
         public PrimitiveColumnContainer<T> HandleOperation(BinaryOperation operation, PrimitiveColumnContainer<T> right)
         {
-            var arithmetic = PrimitiveDataFrameColumnArithmetic<T>.Instance;
-            long nullCount = 0;
+            var arithmetic = Arithmetic<T>.Instance;
+
+            //Divisions are special cases
+            var specialCase = (operation == BinaryOperation.Divide || operation == BinaryOperation.Modulo);
+
+            long nullCount = specialCase ? NullCount : 0;
             for (int i = 0; i < this.Buffers.Count; i++)
             {
                 var mutableBuffer = this.Buffers.GetOrCreateMutable(i);
@@ -22,38 +26,67 @@ public PrimitiveColumnContainer<T> HandleOperation(BinaryOperation operation, Pr
                 var leftValidity = this.NullBitMapBuffers.GetOrCreateMutable(i).Span;
                 var rightValidity = right.NullBitMapBuffers[i].ReadOnlySpan;
 
-                arithmetic.HandleOperation(operation, leftSpan, leftValidity, rightSpan, rightValidity);
-
-                //Calculate NullCount
-                nullCount += BitUtility.GetBitCount(leftValidity, mutableBuffer.Length);
+                if (specialCase)
+                {
+                    for (var j = 0; j < leftSpan.Length; j++)
+                    {
+                        if (BitUtility.GetBit(rightValidity, j))
+                            leftSpan[j] = arithmetic.HandleOperation(operation, leftSpan[j], rightSpan[j]);
+                        else if (BitUtility.GetBit(leftValidity, j))
+                        {
+                            BitUtility.ClearBit(leftValidity, j);
+
+                            //Increase NullCount
+                            nullCount++;
+                        }
+                    }
+                }
+                else
+                {
+                    arithmetic.HandleOperation(operation, leftSpan, rightSpan, leftSpan);
+                    ValidityElementwiseAnd(leftValidity, rightValidity, leftValidity);
+
+                    //Calculate NullCount
+                    nullCount += mutableBuffer.Length - BitUtility.GetBitCount(leftValidity, mutableBuffer.Length);
+                }
             }
 
             NullCount = nullCount;
             return this;
         }
 
-        public PrimitiveColumnContainer<T> HandleOperation(BinaryScalarOperation operation, T right)
+        public PrimitiveColumnContainer<T> HandleOperation(BinaryOperation operation, T right)
         {
-            var arithmetic = PrimitiveDataFrameColumnArithmetic<T>.Instance;
+            var arithmetic = Arithmetic<T>.Instance;
             for (int i = 0; i < this.Buffers.Count; i++)
             {
                 var leftSpan = this.Buffers.GetOrCreateMutable(i).Span;
 
-                arithmetic.HandleOperation(operation, leftSpan, right);
+                arithmetic.HandleOperation(operation, leftSpan, right, leftSpan);
             }
 
             return this;
         }
 
-        public PrimitiveColumnContainer<T> HandleReverseOperation(BinaryScalarOperation operation, T left)
+        public PrimitiveColumnContainer<T> HandleReverseOperation(BinaryOperation operation, T left)
         {
-            var arithmetic = PrimitiveDataFrameColumnArithmetic<T>.Instance;
+            var arithmetic = Arithmetic<T>.Instance;
             for (int i = 0; i < this.Buffers.Count; i++)
             {
                 var rightSpan = this.Buffers.GetOrCreateMutable(i).Span;
                 var rightValidity = this.NullBitMapBuffers[i].ReadOnlySpan;
 
-                arithmetic.HandleOperation(operation, left, rightSpan, rightValidity);
+                if (operation == BinaryOperation.Divide || operation == BinaryOperation.Modulo)
+                {
+                    //Divisions are special cases
+                    for (var j = 0; j < rightSpan.Length; j++)
+                    {
+                        if (BitUtility.GetBit(rightValidity, j))
+                            rightSpan[j] = arithmetic.HandleOperation(operation, left, rightSpan[j]);
+                    }
+                }
+                else
+                    arithmetic.HandleOperation(operation, left, rightSpan, rightSpan);
             }
 
             return this;
@@ -61,12 +94,12 @@ public PrimitiveColumnContainer<T> HandleReverseOperation(BinaryScalarOperation
 
         public PrimitiveColumnContainer<T> HandleOperation(BinaryIntOperation operation, int right)
         {
-            var arithmetic = PrimitiveDataFrameColumnArithmetic<T>.Instance;
+            var arithmetic = Arithmetic<T>.Instance;
             for (int i = 0; i < this.Buffers.Count; i++)
             {
                 var leftSpan = this.Buffers.GetOrCreateMutable(i).Span;
 
-                arithmetic.HandleOperation(operation, leftSpan, right);
+                arithmetic.HandleOperation(operation, leftSpan, right, leftSpan);
             }
 
             return this;
@@ -74,7 +107,7 @@ public PrimitiveColumnContainer<T> HandleOperation(BinaryIntOperation operation,
 
         public PrimitiveColumnContainer<bool> HandleOperation(ComparisonOperation operation, PrimitiveColumnContainer<T> right)
         {
-            var arithmetic = PrimitiveDataFrameColumnArithmetic<T>.Instance;
+            var arithmetic = Arithmetic<T>.Instance;
 
             var ret = new PrimitiveColumnContainer<bool>(Length);
             long offset = 0;
@@ -90,11 +123,11 @@ public PrimitiveColumnContainer<bool> HandleOperation(ComparisonOperation operat
             return ret;
         }
 
-        public PrimitiveColumnContainer<bool> HandleOperation(ComparisonScalarOperation operation, T right)
+        public PrimitiveColumnContainer<bool> HandleOperation(ComparisonOperation operation, T right)
         {
             var ret = new PrimitiveColumnContainer<bool>(Length);
             long offset = 0;
-            var arithmetic = PrimitiveDataFrameColumnArithmetic<T>.Instance;
+            var arithmetic = Arithmetic<T>.Instance;
             for (int i = 0; i < this.Buffers.Count; i++)
             {
                 var leftSpan = this.Buffers[i].ReadOnlySpan;
@@ -104,5 +137,11 @@ public PrimitiveColumnContainer<bool> HandleOperation(ComparisonScalarOperation
 
             return ret;
         }
+
+        private static void ValidityElementwiseAnd(ReadOnlySpan<byte> left, ReadOnlySpan<byte> right, Span<byte> destination)
+        {
+            for (var i = 0; i < left.Length; i++)
+                destination[i] = (byte)(left[i] & right[i]);
+        }
     }
 }
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationAPIs.ExplodedColumns.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationAPIs.ExplodedColumns.cs
index f879536391..7ae05317d7 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationAPIs.ExplodedColumns.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationAPIs.ExplodedColumns.cs
@@ -3041,552 +3041,552 @@ public partial class ByteDataFrameColumn
         public Int32DataFrameColumn Add(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn Add(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseAdd(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseSubtract(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseMultiply(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseDivide(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseModulo(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn Add(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseAdd(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseDivide(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseModulo(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public UInt32DataFrameColumn Add(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseAdd(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return uintColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public UInt32DataFrameColumn Subtract(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseSubtract(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return uintColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public UInt32DataFrameColumn Multiply(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseMultiply(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return uintColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public UInt32DataFrameColumn Divide(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseDivide(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return uintColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public UInt32DataFrameColumn Modulo(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseModulo(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return uintColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public UInt64DataFrameColumn Add(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseAdd(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return ulongColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public UInt64DataFrameColumn Subtract(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseSubtract(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return ulongColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public UInt64DataFrameColumn Multiply(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseMultiply(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return ulongColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public UInt64DataFrameColumn Divide(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseDivide(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return ulongColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public UInt64DataFrameColumn Modulo(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseModulo(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return ulongColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
     }
 
@@ -3595,442 +3595,442 @@ public partial class DecimalDataFrameColumn
         public DecimalDataFrameColumn Add(byte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseAdd(byte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Subtract(byte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseSubtract(byte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Multiply(byte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseMultiply(byte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Divide(byte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseDivide(byte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Modulo(byte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseModulo(byte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(decimal value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, value, inPlace);
         }
         public DecimalDataFrameColumn ReverseAdd(decimal value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace);
         }
         public DecimalDataFrameColumn Subtract(decimal value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace);
         }
         public DecimalDataFrameColumn ReverseSubtract(decimal value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace);
         }
         public DecimalDataFrameColumn Multiply(decimal value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace);
         }
         public DecimalDataFrameColumn ReverseMultiply(decimal value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace);
         }
         public DecimalDataFrameColumn Divide(decimal value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, value, inPlace);
         }
         public DecimalDataFrameColumn ReverseDivide(decimal value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace);
         }
         public DecimalDataFrameColumn Modulo(decimal value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace);
         }
         public DecimalDataFrameColumn ReverseModulo(decimal value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace);
         }
         public DecimalDataFrameColumn Add(int value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseAdd(int value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Subtract(int value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseSubtract(int value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Multiply(int value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseMultiply(int value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Divide(int value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseDivide(int value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Modulo(int value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseModulo(int value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(long value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseAdd(long value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Subtract(long value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseSubtract(long value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Multiply(long value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseMultiply(long value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Divide(long value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseDivide(long value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Modulo(long value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseModulo(long value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(sbyte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseAdd(sbyte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Subtract(sbyte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseSubtract(sbyte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Multiply(sbyte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseMultiply(sbyte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Divide(sbyte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseDivide(sbyte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Modulo(sbyte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseModulo(sbyte value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(short value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseAdd(short value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Subtract(short value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseSubtract(short value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Multiply(short value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseMultiply(short value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Divide(short value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseDivide(short value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Modulo(short value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseModulo(short value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(uint value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseAdd(uint value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Subtract(uint value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseSubtract(uint value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Multiply(uint value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseMultiply(uint value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Divide(uint value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseDivide(uint value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Modulo(uint value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseModulo(uint value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(ulong value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseAdd(ulong value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Subtract(ulong value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseSubtract(ulong value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Multiply(ulong value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseMultiply(ulong value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Divide(ulong value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseDivide(ulong value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Modulo(ulong value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseModulo(ulong value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(ushort value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseAdd(ushort value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Subtract(ushort value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseSubtract(ushort value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Multiply(ushort value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseMultiply(ushort value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Divide(ushort value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseDivide(ushort value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Modulo(ushort value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn ReverseModulo(ushort value, bool inPlace = false)
         {
             var convertedValue = (decimal)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
     }
 
@@ -4039,492 +4039,492 @@ public partial class DoubleDataFrameColumn
         public DoubleDataFrameColumn Add(byte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(byte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Subtract(byte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(byte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Multiply(byte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(byte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Divide(byte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(byte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Modulo(byte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(byte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Add(double value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, value, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(double value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace);
         }
         public DoubleDataFrameColumn Subtract(double value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace);
         }
         public DoubleDataFrameColumn Multiply(double value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace);
         }
         public DoubleDataFrameColumn Divide(double value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, value, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(double value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace);
         }
         public DoubleDataFrameColumn Modulo(double value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(double value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace);
         }
         public DoubleDataFrameColumn Add(float value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(float value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Subtract(float value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(float value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Multiply(float value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(float value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Divide(float value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(float value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Modulo(float value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(float value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Add(int value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(int value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Subtract(int value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(int value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Multiply(int value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(int value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Divide(int value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(int value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Modulo(int value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(int value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Add(long value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(long value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Subtract(long value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(long value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Multiply(long value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(long value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Divide(long value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(long value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Modulo(long value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(long value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Add(sbyte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(sbyte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Subtract(sbyte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(sbyte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Multiply(sbyte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(sbyte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Divide(sbyte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(sbyte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Modulo(sbyte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(sbyte value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Add(short value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(short value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Subtract(short value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(short value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Multiply(short value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(short value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Divide(short value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(short value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Modulo(short value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(short value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Add(uint value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(uint value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Subtract(uint value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(uint value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Multiply(uint value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(uint value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Divide(uint value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(uint value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Modulo(uint value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(uint value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Add(ulong value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(ulong value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Subtract(ulong value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(ulong value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Multiply(ulong value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(ulong value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Divide(ulong value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(ulong value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Modulo(ulong value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(ulong value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Add(ushort value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseAdd(ushort value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Subtract(ushort value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseSubtract(ushort value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Multiply(ushort value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseMultiply(ushort value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Divide(ushort value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseDivide(ushort value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Modulo(ushort value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn ReverseModulo(ushort value, bool inPlace = false)
         {
             var convertedValue = (double)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
     }
 
@@ -4533,492 +4533,492 @@ public partial class SingleDataFrameColumn
         public SingleDataFrameColumn Add(byte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseAdd(byte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Subtract(byte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseSubtract(byte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Multiply(byte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseMultiply(byte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Divide(byte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseDivide(byte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Modulo(byte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseModulo(byte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DoubleDataFrameColumn Add(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseAdd(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseDivide(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseModulo(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(float value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, value, inPlace);
         }
         public SingleDataFrameColumn ReverseAdd(float value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace);
         }
         public SingleDataFrameColumn Subtract(float value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace);
         }
         public SingleDataFrameColumn ReverseSubtract(float value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace);
         }
         public SingleDataFrameColumn Multiply(float value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace);
         }
         public SingleDataFrameColumn ReverseMultiply(float value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace);
         }
         public SingleDataFrameColumn Divide(float value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, value, inPlace);
         }
         public SingleDataFrameColumn ReverseDivide(float value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace);
         }
         public SingleDataFrameColumn Modulo(float value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace);
         }
         public SingleDataFrameColumn ReverseModulo(float value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace);
         }
         public SingleDataFrameColumn Add(int value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseAdd(int value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Subtract(int value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseSubtract(int value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Multiply(int value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseMultiply(int value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Divide(int value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseDivide(int value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Modulo(int value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseModulo(int value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Add(long value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseAdd(long value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Subtract(long value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseSubtract(long value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Multiply(long value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseMultiply(long value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Divide(long value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseDivide(long value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Modulo(long value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseModulo(long value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Add(sbyte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseAdd(sbyte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Subtract(sbyte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseSubtract(sbyte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Multiply(sbyte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseMultiply(sbyte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Divide(sbyte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseDivide(sbyte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Modulo(sbyte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseModulo(sbyte value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Add(short value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseAdd(short value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Subtract(short value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseSubtract(short value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Multiply(short value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseMultiply(short value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Divide(short value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseDivide(short value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Modulo(short value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseModulo(short value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Add(uint value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseAdd(uint value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Subtract(uint value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseSubtract(uint value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Multiply(uint value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseMultiply(uint value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Divide(uint value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseDivide(uint value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Modulo(uint value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseModulo(uint value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Add(ulong value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseAdd(ulong value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Subtract(ulong value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseSubtract(ulong value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Multiply(ulong value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseMultiply(ulong value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Divide(ulong value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseDivide(ulong value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Modulo(ulong value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseModulo(ulong value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Add(ushort value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseAdd(ushort value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Subtract(ushort value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseSubtract(ushort value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Multiply(ushort value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseMultiply(ushort value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Divide(ushort value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseDivide(ushort value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public SingleDataFrameColumn Modulo(ushort value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public SingleDataFrameColumn ReverseModulo(ushort value, bool inPlace = false)
         {
             var convertedValue = (float)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
     }
 
@@ -5027,542 +5027,542 @@ public partial class Int32DataFrameColumn
         public Int32DataFrameColumn Add(byte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseAdd(byte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Subtract(byte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseSubtract(byte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Multiply(byte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseMultiply(byte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Divide(byte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseDivide(byte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Modulo(byte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseModulo(byte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseAdd(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseSubtract(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseMultiply(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseDivide(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseModulo(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn Add(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseAdd(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseDivide(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseModulo(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(int value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, value, inPlace);
         }
         public Int32DataFrameColumn ReverseAdd(int value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace);
         }
         public Int32DataFrameColumn Subtract(int value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace);
         }
         public Int32DataFrameColumn ReverseSubtract(int value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace);
         }
         public Int32DataFrameColumn Multiply(int value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace);
         }
         public Int32DataFrameColumn ReverseMultiply(int value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace);
         }
         public Int32DataFrameColumn Divide(int value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, value, inPlace);
         }
         public Int32DataFrameColumn ReverseDivide(int value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace);
         }
         public Int32DataFrameColumn Modulo(int value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace);
         }
         public Int32DataFrameColumn ReverseModulo(int value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace);
         }
         public Int64DataFrameColumn Add(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(sbyte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseAdd(sbyte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Subtract(sbyte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseSubtract(sbyte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Multiply(sbyte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseMultiply(sbyte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Divide(sbyte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseDivide(sbyte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Modulo(sbyte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseModulo(sbyte value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Add(short value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseAdd(short value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Subtract(short value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseSubtract(short value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Multiply(short value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseMultiply(short value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Divide(short value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseDivide(short value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Modulo(short value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseModulo(short value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Add(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(ushort value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseAdd(ushort value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Subtract(ushort value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseSubtract(ushort value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Multiply(ushort value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseMultiply(ushort value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Divide(ushort value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseDivide(ushort value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int32DataFrameColumn Modulo(ushort value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public Int32DataFrameColumn ReverseModulo(ushort value, bool inPlace = false)
         {
             var convertedValue = (int)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
     }
 
@@ -5571,492 +5571,492 @@ public partial class Int64DataFrameColumn
         public Int64DataFrameColumn Add(byte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseAdd(byte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Subtract(byte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseSubtract(byte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Multiply(byte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseMultiply(byte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Divide(byte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseDivide(byte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Modulo(byte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseModulo(byte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseAdd(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseSubtract(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseMultiply(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseDivide(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseModulo(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn Add(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseAdd(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseDivide(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseModulo(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(int value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseAdd(int value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Subtract(int value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseSubtract(int value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Multiply(int value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseMultiply(int value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Divide(int value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseDivide(int value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Modulo(int value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseModulo(int value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Add(long value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, value, inPlace);
         }
         public Int64DataFrameColumn ReverseAdd(long value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace);
         }
         public Int64DataFrameColumn Subtract(long value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace);
         }
         public Int64DataFrameColumn ReverseSubtract(long value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace);
         }
         public Int64DataFrameColumn Multiply(long value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace);
         }
         public Int64DataFrameColumn ReverseMultiply(long value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace);
         }
         public Int64DataFrameColumn Divide(long value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, value, inPlace);
         }
         public Int64DataFrameColumn ReverseDivide(long value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace);
         }
         public Int64DataFrameColumn Modulo(long value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace);
         }
         public Int64DataFrameColumn ReverseModulo(long value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace);
         }
         public Int64DataFrameColumn Add(sbyte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseAdd(sbyte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Subtract(sbyte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseSubtract(sbyte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Multiply(sbyte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseMultiply(sbyte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Divide(sbyte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseDivide(sbyte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Modulo(sbyte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseModulo(sbyte value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Add(short value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseAdd(short value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Subtract(short value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseSubtract(short value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Multiply(short value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseMultiply(short value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Divide(short value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseDivide(short value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Modulo(short value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseModulo(short value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Add(uint value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseAdd(uint value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Subtract(uint value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseSubtract(uint value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Multiply(uint value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseMultiply(uint value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Divide(uint value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseDivide(uint value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Modulo(uint value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseModulo(uint value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Add(ushort value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseAdd(ushort value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Subtract(ushort value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseSubtract(ushort value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Multiply(ushort value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseMultiply(ushort value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Divide(ushort value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseDivide(ushort value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public Int64DataFrameColumn Modulo(ushort value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public Int64DataFrameColumn ReverseModulo(ushort value, bool inPlace = false)
         {
             var convertedValue = (long)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
     }
 
@@ -6065,552 +6065,552 @@ public partial class SByteDataFrameColumn
         public Int32DataFrameColumn Add(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn Add(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseAdd(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseSubtract(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseMultiply(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseDivide(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseModulo(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn Add(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseAdd(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseDivide(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseModulo(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
     }
 
@@ -6619,552 +6619,552 @@ public partial class Int16DataFrameColumn
         public Int32DataFrameColumn Add(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn Add(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseAdd(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseSubtract(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseMultiply(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseDivide(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseModulo(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn Add(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseAdd(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseDivide(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseModulo(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(uint value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(ulong value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
     }
 
@@ -7173,542 +7173,542 @@ public partial class UInt32DataFrameColumn
         public UInt32DataFrameColumn Add(byte value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseAdd(byte value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn Subtract(byte value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseSubtract(byte value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn Multiply(byte value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseMultiply(byte value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn Divide(byte value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseDivide(byte value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn Modulo(byte value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseModulo(byte value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseAdd(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseSubtract(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseMultiply(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseDivide(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseModulo(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn Add(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseAdd(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseDivide(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseModulo(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(int value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(int value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(int value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(int value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(int value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(int value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(int value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(int value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(int value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(int value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(sbyte value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(sbyte value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(sbyte value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(sbyte value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(sbyte value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(sbyte value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(sbyte value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(sbyte value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(sbyte value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(sbyte value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(short value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(short value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(short value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(short value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(short value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(short value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(short value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(short value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(short value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(short value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public UInt32DataFrameColumn Add(uint value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, value, inPlace);
         }
         public UInt32DataFrameColumn ReverseAdd(uint value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace);
         }
         public UInt32DataFrameColumn Subtract(uint value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace);
         }
         public UInt32DataFrameColumn ReverseSubtract(uint value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace);
         }
         public UInt32DataFrameColumn Multiply(uint value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace);
         }
         public UInt32DataFrameColumn ReverseMultiply(uint value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace);
         }
         public UInt32DataFrameColumn Divide(uint value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, value, inPlace);
         }
         public UInt32DataFrameColumn ReverseDivide(uint value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace);
         }
         public UInt32DataFrameColumn Modulo(uint value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace);
         }
         public UInt32DataFrameColumn ReverseModulo(uint value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace);
         }
         public UInt64DataFrameColumn Add(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseAdd(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return ulongColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public UInt64DataFrameColumn Subtract(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseSubtract(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return ulongColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public UInt64DataFrameColumn Multiply(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseMultiply(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return ulongColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public UInt64DataFrameColumn Divide(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseDivide(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return ulongColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public UInt64DataFrameColumn Modulo(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseModulo(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return ulongColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public UInt32DataFrameColumn Add(ushort value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseAdd(ushort value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn Subtract(ushort value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseSubtract(ushort value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn Multiply(ushort value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseMultiply(ushort value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn Divide(ushort value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseDivide(ushort value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn Modulo(ushort value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public UInt32DataFrameColumn ReverseModulo(ushort value, bool inPlace = false)
         {
             var convertedValue = (uint)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
     }
 
@@ -7717,492 +7717,492 @@ public partial class UInt64DataFrameColumn
         public UInt64DataFrameColumn Add(byte value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseAdd(byte value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Subtract(byte value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseSubtract(byte value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Multiply(byte value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseMultiply(byte value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Divide(byte value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseDivide(byte value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Modulo(byte value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseModulo(byte value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public DecimalDataFrameColumn Add(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseAdd(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseSubtract(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseMultiply(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseDivide(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseModulo(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn Add(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseAdd(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseDivide(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseModulo(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(int value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(int value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(int value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(int value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(int value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(int value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(int value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(int value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(int value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(int value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(sbyte value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(sbyte value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(sbyte value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(sbyte value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(sbyte value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(sbyte value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(sbyte value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(sbyte value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(sbyte value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(sbyte value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(short value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(short value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(short value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(short value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(short value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(short value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(short value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(short value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(short value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(short value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public UInt64DataFrameColumn Add(uint value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseAdd(uint value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Subtract(uint value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseSubtract(uint value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Multiply(uint value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseMultiply(uint value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Divide(uint value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseDivide(uint value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Modulo(uint value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseModulo(uint value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Add(ulong value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, value, inPlace);
         }
         public UInt64DataFrameColumn ReverseAdd(ulong value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace);
         }
         public UInt64DataFrameColumn Subtract(ulong value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace);
         }
         public UInt64DataFrameColumn ReverseSubtract(ulong value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace);
         }
         public UInt64DataFrameColumn Multiply(ulong value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace);
         }
         public UInt64DataFrameColumn ReverseMultiply(ulong value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace);
         }
         public UInt64DataFrameColumn Divide(ulong value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, value, inPlace);
         }
         public UInt64DataFrameColumn ReverseDivide(ulong value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace);
         }
         public UInt64DataFrameColumn Modulo(ulong value, bool inPlace = false)
         {
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace);
         }
         public UInt64DataFrameColumn ReverseModulo(ulong value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace);
         }
         public UInt64DataFrameColumn Add(ushort value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseAdd(ushort value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Add, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Add, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Subtract(ushort value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseSubtract(ushort value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Multiply(ushort value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseMultiply(ushort value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Divide(ushort value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseDivide(ushort value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Divide, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn Modulo(ushort value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
         public UInt64DataFrameColumn ReverseModulo(ushort value, bool inPlace = false)
         {
             var convertedValue = (ulong)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, convertedValue, inPlace);
         }
     }
 
@@ -8211,552 +8211,552 @@ public partial class UInt16DataFrameColumn
         public Int32DataFrameColumn Add(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(byte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn Add(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseAdd(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DecimalDataFrameColumn Subtract(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseSubtract(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DecimalDataFrameColumn Multiply(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseMultiply(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DecimalDataFrameColumn Divide(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseDivide(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DecimalDataFrameColumn Modulo(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return decimalColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DecimalDataFrameColumn ReverseModulo(decimal value)
         {
             var decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return decimalColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn Add(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseAdd(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public DoubleDataFrameColumn Subtract(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseSubtract(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public DoubleDataFrameColumn Multiply(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseMultiply(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public DoubleDataFrameColumn Divide(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseDivide(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public DoubleDataFrameColumn Modulo(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return doubleColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public DoubleDataFrameColumn ReverseModulo(double value)
         {
             var doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return doubleColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn Add(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseAdd(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public SingleDataFrameColumn Subtract(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseSubtract(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public SingleDataFrameColumn Multiply(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseMultiply(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public SingleDataFrameColumn Divide(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseDivide(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public SingleDataFrameColumn Modulo(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public SingleDataFrameColumn ReverseModulo(float value)
         {
             var floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return floatColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(int value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn Add(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseAdd(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int64DataFrameColumn Subtract(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseSubtract(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int64DataFrameColumn Multiply(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseMultiply(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int64DataFrameColumn Divide(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseDivide(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int64DataFrameColumn Modulo(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int64DataFrameColumn ReverseModulo(long value)
         {
             var longColumn = CloneAsInt64Column();
-            return longColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return longColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(sbyte value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(short value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public UInt32DataFrameColumn Add(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseAdd(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return uintColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public UInt32DataFrameColumn Subtract(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseSubtract(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return uintColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public UInt32DataFrameColumn Multiply(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseMultiply(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return uintColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public UInt32DataFrameColumn Divide(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseDivide(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return uintColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public UInt32DataFrameColumn Modulo(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return uintColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public UInt32DataFrameColumn ReverseModulo(uint value)
         {
             var uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return uintColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public UInt64DataFrameColumn Add(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseAdd(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return ulongColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public UInt64DataFrameColumn Subtract(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseSubtract(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return ulongColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public UInt64DataFrameColumn Multiply(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseMultiply(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return ulongColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public UInt64DataFrameColumn Divide(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseDivide(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return ulongColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public UInt64DataFrameColumn Modulo(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return ulongColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public UInt64DataFrameColumn ReverseModulo(ulong value)
         {
             var ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return ulongColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn Add(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseAdd(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Add, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace: true);
         }
         public Int32DataFrameColumn Subtract(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseSubtract(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Subtract, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace: true);
         }
         public Int32DataFrameColumn Multiply(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseMultiply(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Multiply, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace: true);
         }
         public Int32DataFrameColumn Divide(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseDivide(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Divide, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace: true);
         }
         public Int32DataFrameColumn Modulo(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
         public Int32DataFrameColumn ReverseModulo(ushort value)
         {
             var intColumn = CloneAsInt32Column();
-            return intColumn.HandleReverseOperationImplementation(BinaryScalarOperation.Modulo, value, inPlace: true);
+            return intColumn.HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace: true);
         }
     }
 
@@ -8779,7 +8779,7 @@ public partial class BooleanDataFrameColumn
         public new BooleanDataFrameColumn And(bool value, bool inPlace = false)
         {
             BooleanDataFrameColumn retColumn = inPlace ? this : CloneAsBooleanColumn();
-            retColumn.ColumnContainer.HandleOperation(BinaryScalarOperation.And, value);
+            retColumn.ColumnContainer.HandleOperation(BinaryOperation.And, value);
             return retColumn;
         }
     }
@@ -8803,7 +8803,7 @@ public partial class BooleanDataFrameColumn
         public new BooleanDataFrameColumn Or(bool value, bool inPlace = false)
         {
             BooleanDataFrameColumn retColumn = inPlace ? this : CloneAsBooleanColumn();
-            retColumn.ColumnContainer.HandleOperation(BinaryScalarOperation.Or, value);
+            retColumn.ColumnContainer.HandleOperation(BinaryOperation.Or, value);
             return retColumn;
         }
     }
@@ -8827,7 +8827,7 @@ public partial class BooleanDataFrameColumn
         public new BooleanDataFrameColumn Xor(bool value, bool inPlace = false)
         {
             BooleanDataFrameColumn retColumn = inPlace ? this : CloneAsBooleanColumn();
-            retColumn.ColumnContainer.HandleOperation(BinaryScalarOperation.Xor, value);
+            retColumn.ColumnContainer.HandleOperation(BinaryOperation.Xor, value);
             return retColumn;
         }
     }
@@ -12321,27 +12321,27 @@ public partial class BooleanDataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(bool value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(bool value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(bool value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(bool value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(bool value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(bool value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
     }
 
@@ -12349,327 +12349,327 @@ public partial class ByteDataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             byte otherbyteValue = (byte)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherbyteValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             byte otherbyteValue = (byte)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherbyteValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             byte otherbyteValue = (byte)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherbyteValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             byte otherbyteValue = (byte)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherbyteValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             byte otherbyteValue = (byte)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherbyteValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             byte otherbyteValue = (byte)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherbyteValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
     }
 
@@ -12678,266 +12678,266 @@ public partial class DecimalDataFrameColumn
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(decimal value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(decimal value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(decimal value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(decimal value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(decimal value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(decimal value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdecimalValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             decimal otherdecimalValue = (decimal)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdecimalValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdecimalValue);
         }
     }
 
@@ -12946,296 +12946,296 @@ public partial class DoubleDataFrameColumn
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherdoubleValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             double otherdoubleValue = (double)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherdoubleValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherdoubleValue);
         }
     }
 
@@ -13244,296 +13244,296 @@ public partial class SingleDataFrameColumn
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherfloatValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             float otherfloatValue = (float)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherfloatValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherfloatValue);
         }
     }
 
@@ -13542,326 +13542,326 @@ public partial class Int32DataFrameColumn
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             int otherintValue = (int)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherintValue);
         }
     }
 
@@ -13870,296 +13870,296 @@ public partial class Int64DataFrameColumn
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherlongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             long otherlongValue = (long)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherlongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherlongValue);
         }
     }
 
@@ -14168,326 +14168,326 @@ public partial class SByteDataFrameColumn
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             sbyte othersbyteValue = (sbyte)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, othersbyteValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, othersbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             sbyte othersbyteValue = (sbyte)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, othersbyteValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, othersbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             sbyte othersbyteValue = (sbyte)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, othersbyteValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, othersbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             sbyte othersbyteValue = (sbyte)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, othersbyteValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, othersbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             sbyte othersbyteValue = (sbyte)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, othersbyteValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, othersbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             sbyte othersbyteValue = (sbyte)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, othersbyteValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, othersbyteValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             Int16DataFrameColumn shortColumn = CloneAsInt16Column();
-            return shortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return shortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             UInt16DataFrameColumn ushortColumn = CloneAsUInt16Column();
-            return ushortColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return ushortColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
     }
 
@@ -14496,326 +14496,326 @@ public partial class Int16DataFrameColumn
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             short othershortValue = (short)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, othershortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             short othershortValue = (short)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, othershortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             short othershortValue = (short)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, othershortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             short othershortValue = (short)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, othershortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             short othershortValue = (short)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, othershortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             short othershortValue = (short)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, othershortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             short othershortValue = (short)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, othershortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             short othershortValue = (short)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, othershortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             short othershortValue = (short)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, othershortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             short othershortValue = (short)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, othershortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             short othershortValue = (short)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, othershortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             short othershortValue = (short)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, othershortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             short othershortValue = (short)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, othershortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             short othershortValue = (short)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, othershortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             short othershortValue = (short)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, othershortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             short othershortValue = (short)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, othershortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             short othershortValue = (short)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, othershortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, othershortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             short othershortValue = (short)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, othershortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, othershortValue);
         }
     }
 
@@ -14824,326 +14824,326 @@ public partial class UInt32DataFrameColumn
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otheruintValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             uint otheruintValue = (uint)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otheruintValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otheruintValue);
         }
     }
 
@@ -15152,296 +15152,296 @@ public partial class UInt64DataFrameColumn
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherulongValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
             ulong otherulongValue = (ulong)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherulongValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherulongValue);
         }
     }
 
@@ -15450,326 +15450,326 @@ public partial class UInt16DataFrameColumn
         public BooleanDataFrameColumn ElementwiseEquals(byte value)
         {
             ushort otherushortValue = (ushort)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherushortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(byte value)
         {
             ushort otherushortValue = (ushort)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherushortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(byte value)
         {
             ushort otherushortValue = (ushort)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherushortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(byte value)
         {
             ushort otherushortValue = (ushort)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherushortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(byte value)
         {
             ushort otherushortValue = (ushort)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherushortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(byte value)
         {
             ushort otherushortValue = (ushort)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherushortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(decimal value)
         {
             DecimalDataFrameColumn decimalColumn = CloneAsDecimalColumn();
-            return decimalColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return decimalColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(double value)
         {
             DoubleDataFrameColumn doubleColumn = CloneAsDoubleColumn();
-            return doubleColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return doubleColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(float value)
         {
             SingleDataFrameColumn floatColumn = CloneAsSingleColumn();
-            return floatColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return floatColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(int value)
         {
             Int32DataFrameColumn intColumn = CloneAsInt32Column();
-            return intColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return intColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(long value)
         {
             Int64DataFrameColumn longColumn = CloneAsInt64Column();
-            return longColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return longColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(sbyte value)
         {
             ushort otherushortValue = (ushort)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherushortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(sbyte value)
         {
             ushort otherushortValue = (ushort)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherushortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(sbyte value)
         {
             ushort otherushortValue = (ushort)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherushortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(sbyte value)
         {
             ushort otherushortValue = (ushort)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherushortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(sbyte value)
         {
             ushort otherushortValue = (ushort)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherushortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(sbyte value)
         {
             ushort otherushortValue = (ushort)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherushortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(short value)
         {
             ushort otherushortValue = (ushort)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, otherushortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(short value)
         {
             ushort otherushortValue = (ushort)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, otherushortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(short value)
         {
             ushort otherushortValue = (ushort)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, otherushortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(short value)
         {
             ushort otherushortValue = (ushort)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, otherushortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(short value)
         {
             ushort otherushortValue = (ushort)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, otherushortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(short value)
         {
             ushort otherushortValue = (ushort)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, otherushortValue);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, otherushortValue);
         }
         public BooleanDataFrameColumn ElementwiseEquals(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(uint value)
         {
             UInt32DataFrameColumn uintColumn = CloneAsUInt32Column();
-            return uintColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return uintColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ulong value)
         {
             UInt64DataFrameColumn ulongColumn = CloneAsUInt64Column();
-            return ulongColumn.HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return ulongColumn.HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
         public BooleanDataFrameColumn ElementwiseEquals(ushort value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(ushort value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(ushort value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(ushort value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(ushort value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(ushort value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
     }
 
@@ -15777,27 +15777,27 @@ public partial class DateTimeDataFrameColumn
     {
         public BooleanDataFrameColumn ElementwiseEquals(DateTime value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseNotEquals(DateTime value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(DateTime value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThanOrEqual(DateTime value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
         public BooleanDataFrameColumn ElementwiseGreaterThan(DateTime value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
         public BooleanDataFrameColumn ElementwiseLessThan(DateTime value)
         {
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
     }
 
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationAPIs.ExplodedColumns.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationAPIs.ExplodedColumns.tt
index a6efa5cb4a..4a304be83c 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationAPIs.ExplodedColumns.tt
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationAPIs.ExplodedColumns.tt
@@ -199,7 +199,7 @@ void GenerateAllBinaryScalarCombinationsForMethod()
         if (fullReturnType == fullColumnType)
         {
 #>
-            return HandleOperationImplementation(BinaryScalarOperation.<#=methodName#>, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.<#=methodName#>, value, inPlace);
 <#
         }
         else
@@ -207,7 +207,7 @@ void GenerateAllBinaryScalarCombinationsForMethod()
             // Cases such as byte + byte resulting in int. Needs 2 clones
 #>
             var <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
-            return <#=returnType#>Column.HandleOperationImplementation(BinaryScalarOperation.<#=methodName#>, value, inPlace: true);
+            return <#=returnType#>Column.HandleOperationImplementation(BinaryOperation.<#=methodName#>, value, inPlace: true);
 <#
         }
     }
@@ -222,14 +222,14 @@ void GenerateAllBinaryScalarCombinationsForMethod()
             {
 #>
             var <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
-            return <#=returnType#>Column.HandleOperationImplementation(BinaryScalarOperation.<#=methodName#>, value, inPlace: true);
+            return <#=returnType#>Column.HandleOperationImplementation(BinaryOperation.<#=methodName#>, value, inPlace: true);
 <#
             }
             else
             {
 #>
             var convertedValue = (<#=returnType#>)value;
-            return HandleOperationImplementation(BinaryScalarOperation.<#=methodName#>, convertedValue, inPlace);
+            return HandleOperationImplementation(BinaryOperation.<#=methodName#>, convertedValue, inPlace);
 <#
             }
         }
@@ -238,7 +238,7 @@ void GenerateAllBinaryScalarCombinationsForMethod()
             // Cases such as byte + short resulting in int. Needs 2 clones
 #>
             var <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
-            return <#=returnType#>Column.HandleOperationImplementation(BinaryScalarOperation.<#=methodName#>, value, inPlace: true);
+            return <#=returnType#>Column.HandleOperationImplementation(BinaryOperation.<#=methodName#>, value, inPlace: true);
 <#
         }
     }
@@ -282,7 +282,7 @@ void GenerateAllBinaryScalarCombinationsForMethod()
         if (fullReturnType == fullColumnType)
         {
 #>
-            return HandleReverseOperationImplementation(BinaryScalarOperation.<#=operationName#>, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.<#=operationName#>, value, inPlace);
 <#
         }
         else
@@ -290,7 +290,7 @@ void GenerateAllBinaryScalarCombinationsForMethod()
             // Cases such as byte + byte resulting in int. Needs 2 clones
 #>
             var <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
-            return <#=returnType#>Column.HandleReverseOperationImplementation(BinaryScalarOperation.<#=operationName#>, value, inPlace: true);
+            return <#=returnType#>Column.HandleReverseOperationImplementation(BinaryOperation.<#=operationName#>, value, inPlace: true);
 <#
         }
     }
@@ -305,14 +305,14 @@ void GenerateAllBinaryScalarCombinationsForMethod()
             {
 #>
             var <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
-            return <#=returnType#>Column.HandleReverseOperationImplementation(BinaryScalarOperation.<#=operationName#>, value, inPlace: true);
+            return <#=returnType#>Column.HandleReverseOperationImplementation(BinaryOperation.<#=operationName#>, value, inPlace: true);
 <#
             }
             else
             {
 #>
             var convertedValue = (<#=returnType#>)value;
-            return HandleReverseOperationImplementation(BinaryScalarOperation.<#=operationName#>, convertedValue, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.<#=operationName#>, convertedValue, inPlace);
 <#
             }
         }
@@ -321,7 +321,7 @@ void GenerateAllBinaryScalarCombinationsForMethod()
             // Cases such as byte + short resulting in int. Needs 2 clones
 #>
             var <#=returnType#>Column = CloneAs<#=capitalizedReturnType#>Column();
-            return <#=returnType#>Column.HandleReverseOperationImplementation(BinaryScalarOperation.<#=operationName#>, value, inPlace: true);
+            return <#=returnType#>Column.HandleReverseOperationImplementation(BinaryOperation.<#=operationName#>, value, inPlace: true);
 <#
         }
     }
@@ -368,7 +368,7 @@ void GenerateAllBinaryScalarBitwiseOperationsForMethod(string methodName)
         public new BooleanDataFrameColumn <#=methodName#>(bool value, bool inPlace = false)
         {
             BooleanDataFrameColumn retColumn = inPlace ? this : CloneAsBooleanColumn();
-            retColumn.ColumnContainer.HandleOperation(BinaryScalarOperation.<#=methodName#>, value);
+            retColumn.ColumnContainer.HandleOperation(BinaryOperation.<#=methodName#>, value);
             return retColumn;
         }
     }
@@ -514,7 +514,7 @@ foreach (MethodConfiguration method in methodConfiguration)
     if (columnType == otherColumnType)
     {
 #>
-            return HandleOperationImplementation(ComparisonScalarOperation.<#=methodName#>, value);
+            return HandleOperationImplementation(ComparisonOperation.<#=methodName#>, value);
 <#
     }
     else
@@ -525,14 +525,14 @@ foreach (MethodConfiguration method in methodConfiguration)
         {
 #>
             <#=fullOtherColumnType#> <#=otherColumnType#>Column = CloneAs<#=capitalizedOtherColumnType#>Column();
-            return <#=otherColumnType#>Column.HandleOperationImplementation(ComparisonScalarOperation.<#=methodName#>, value);
+            return <#=otherColumnType#>Column.HandleOperationImplementation(ComparisonOperation.<#=methodName#>, value);
 <#
         }
         else
         {
 #>
             <#=columnType#> other<#=columnType#>Value = (<#=columnType#>)value;
-            return HandleOperationImplementation(ComparisonScalarOperation.<#=methodName#>, other<#=columnType#>Value);
+            return HandleOperationImplementation(ComparisonOperation.<#=methodName#>, other<#=columnType#>Value);
 <#
         }
 #>
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs
index a91a63f3f7..d171d6a51a 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs
@@ -27,14 +27,14 @@ internal DecimalDataFrameColumn HandleOperationImplementation(BinaryOperation op
         }
 
         //Binary Scalar Operations
-        internal DecimalDataFrameColumn HandleOperationImplementation(BinaryScalarOperation operation, decimal right, bool inPlace = false)
+        internal DecimalDataFrameColumn HandleOperationImplementation(BinaryOperation operation, decimal right, bool inPlace = false)
         {
             var newColumn = inPlace ? this : (DecimalDataFrameColumn)Clone();
             newColumn.ColumnContainer.HandleOperation(operation, right);
             return newColumn;
         }
 
-        internal DecimalDataFrameColumn HandleReverseOperationImplementation(BinaryScalarOperation operation, decimal right, bool inPlace = false)
+        internal DecimalDataFrameColumn HandleReverseOperationImplementation(BinaryOperation operation, decimal right, bool inPlace = false)
         {
             var newColumn = inPlace ? this : (DecimalDataFrameColumn)Clone();
             newColumn.ColumnContainer.HandleReverseOperation(operation, right);
@@ -57,14 +57,14 @@ internal DoubleDataFrameColumn HandleOperationImplementation(BinaryOperation ope
         }
 
         //Binary Scalar Operations
-        internal DoubleDataFrameColumn HandleOperationImplementation(BinaryScalarOperation operation, double right, bool inPlace = false)
+        internal DoubleDataFrameColumn HandleOperationImplementation(BinaryOperation operation, double right, bool inPlace = false)
         {
             var newColumn = inPlace ? this : (DoubleDataFrameColumn)Clone();
             newColumn.ColumnContainer.HandleOperation(operation, right);
             return newColumn;
         }
 
-        internal DoubleDataFrameColumn HandleReverseOperationImplementation(BinaryScalarOperation operation, double right, bool inPlace = false)
+        internal DoubleDataFrameColumn HandleReverseOperationImplementation(BinaryOperation operation, double right, bool inPlace = false)
         {
             var newColumn = inPlace ? this : (DoubleDataFrameColumn)Clone();
             newColumn.ColumnContainer.HandleReverseOperation(operation, right);
@@ -87,14 +87,14 @@ internal SingleDataFrameColumn HandleOperationImplementation(BinaryOperation ope
         }
 
         //Binary Scalar Operations
-        internal SingleDataFrameColumn HandleOperationImplementation(BinaryScalarOperation operation, float right, bool inPlace = false)
+        internal SingleDataFrameColumn HandleOperationImplementation(BinaryOperation operation, float right, bool inPlace = false)
         {
             var newColumn = inPlace ? this : (SingleDataFrameColumn)Clone();
             newColumn.ColumnContainer.HandleOperation(operation, right);
             return newColumn;
         }
 
-        internal SingleDataFrameColumn HandleReverseOperationImplementation(BinaryScalarOperation operation, float right, bool inPlace = false)
+        internal SingleDataFrameColumn HandleReverseOperationImplementation(BinaryOperation operation, float right, bool inPlace = false)
         {
             var newColumn = inPlace ? this : (SingleDataFrameColumn)Clone();
             newColumn.ColumnContainer.HandleReverseOperation(operation, right);
@@ -117,14 +117,14 @@ internal Int32DataFrameColumn HandleOperationImplementation(BinaryOperation oper
         }
 
         //Binary Scalar Operations
-        internal Int32DataFrameColumn HandleOperationImplementation(BinaryScalarOperation operation, int right, bool inPlace = false)
+        internal Int32DataFrameColumn HandleOperationImplementation(BinaryOperation operation, int right, bool inPlace = false)
         {
             var newColumn = inPlace ? this : (Int32DataFrameColumn)Clone();
             newColumn.ColumnContainer.HandleOperation(operation, right);
             return newColumn;
         }
 
-        internal Int32DataFrameColumn HandleReverseOperationImplementation(BinaryScalarOperation operation, int right, bool inPlace = false)
+        internal Int32DataFrameColumn HandleReverseOperationImplementation(BinaryOperation operation, int right, bool inPlace = false)
         {
             var newColumn = inPlace ? this : (Int32DataFrameColumn)Clone();
             newColumn.ColumnContainer.HandleReverseOperation(operation, right);
@@ -147,14 +147,14 @@ internal Int64DataFrameColumn HandleOperationImplementation(BinaryOperation oper
         }
 
         //Binary Scalar Operations
-        internal Int64DataFrameColumn HandleOperationImplementation(BinaryScalarOperation operation, long right, bool inPlace = false)
+        internal Int64DataFrameColumn HandleOperationImplementation(BinaryOperation operation, long right, bool inPlace = false)
         {
             var newColumn = inPlace ? this : (Int64DataFrameColumn)Clone();
             newColumn.ColumnContainer.HandleOperation(operation, right);
             return newColumn;
         }
 
-        internal Int64DataFrameColumn HandleReverseOperationImplementation(BinaryScalarOperation operation, long right, bool inPlace = false)
+        internal Int64DataFrameColumn HandleReverseOperationImplementation(BinaryOperation operation, long right, bool inPlace = false)
         {
             var newColumn = inPlace ? this : (Int64DataFrameColumn)Clone();
             newColumn.ColumnContainer.HandleReverseOperation(operation, right);
@@ -177,14 +177,14 @@ internal UInt32DataFrameColumn HandleOperationImplementation(BinaryOperation ope
         }
 
         //Binary Scalar Operations
-        internal UInt32DataFrameColumn HandleOperationImplementation(BinaryScalarOperation operation, uint right, bool inPlace = false)
+        internal UInt32DataFrameColumn HandleOperationImplementation(BinaryOperation operation, uint right, bool inPlace = false)
         {
             var newColumn = inPlace ? this : (UInt32DataFrameColumn)Clone();
             newColumn.ColumnContainer.HandleOperation(operation, right);
             return newColumn;
         }
 
-        internal UInt32DataFrameColumn HandleReverseOperationImplementation(BinaryScalarOperation operation, uint right, bool inPlace = false)
+        internal UInt32DataFrameColumn HandleReverseOperationImplementation(BinaryOperation operation, uint right, bool inPlace = false)
         {
             var newColumn = inPlace ? this : (UInt32DataFrameColumn)Clone();
             newColumn.ColumnContainer.HandleReverseOperation(operation, right);
@@ -207,14 +207,14 @@ internal UInt64DataFrameColumn HandleOperationImplementation(BinaryOperation ope
         }
 
         //Binary Scalar Operations
-        internal UInt64DataFrameColumn HandleOperationImplementation(BinaryScalarOperation operation, ulong right, bool inPlace = false)
+        internal UInt64DataFrameColumn HandleOperationImplementation(BinaryOperation operation, ulong right, bool inPlace = false)
         {
             var newColumn = inPlace ? this : (UInt64DataFrameColumn)Clone();
             newColumn.ColumnContainer.HandleOperation(operation, right);
             return newColumn;
         }
 
-        internal UInt64DataFrameColumn HandleReverseOperationImplementation(BinaryScalarOperation operation, ulong right, bool inPlace = false)
+        internal UInt64DataFrameColumn HandleReverseOperationImplementation(BinaryOperation operation, ulong right, bool inPlace = false)
         {
             var newColumn = inPlace ? this : (UInt64DataFrameColumn)Clone();
             newColumn.ColumnContainer.HandleReverseOperation(operation, right);
@@ -229,7 +229,7 @@ internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperatio
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
 
-        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, bool value)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, bool value)
         {
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
@@ -242,7 +242,7 @@ internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperatio
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
 
-        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, byte value)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, byte value)
         {
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
@@ -255,7 +255,7 @@ internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperatio
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
 
-        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, decimal value)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, decimal value)
         {
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
@@ -268,7 +268,7 @@ internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperatio
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
 
-        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, double value)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, double value)
         {
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
@@ -281,7 +281,7 @@ internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperatio
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
 
-        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, float value)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, float value)
         {
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
@@ -294,7 +294,7 @@ internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperatio
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
 
-        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, int value)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, int value)
         {
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
@@ -307,7 +307,7 @@ internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperatio
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
 
-        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, long value)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, long value)
         {
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
@@ -320,7 +320,7 @@ internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperatio
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
 
-        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, sbyte value)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, sbyte value)
         {
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
@@ -333,7 +333,7 @@ internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperatio
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
 
-        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, short value)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, short value)
         {
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
@@ -346,7 +346,7 @@ internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperatio
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
 
-        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, uint value)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, uint value)
         {
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
@@ -359,7 +359,7 @@ internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperatio
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
 
-        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, ulong value)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, ulong value)
         {
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
@@ -372,7 +372,7 @@ internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperatio
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
 
-        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, ushort value)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, ushort value)
         {
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
@@ -385,7 +385,7 @@ internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperatio
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
 
-        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, DateTime value)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, DateTime 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 f3dfc830d8..23db336530 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt
@@ -81,14 +81,14 @@ void GenerateAllBinaryCombinationsForMethods()
         }
 
         //Binary Scalar Operations
-        internal <#=fullReturnType#> HandleOperationImplementation(BinaryScalarOperation operation, <#=otherColumnType#> right, bool inPlace = false)
+        internal <#=fullReturnType#> HandleOperationImplementation(BinaryOperation operation, <#=otherColumnType#> right, bool inPlace = false)
         {
             var newColumn = inPlace ? this : (<#=fullReturnType#>)Clone();
             newColumn.ColumnContainer.HandleOperation(operation, right);
             return newColumn;
         }
 
-        internal <#=fullReturnType#> HandleReverseOperationImplementation(BinaryScalarOperation operation, <#=otherColumnType#> right, bool inPlace = false)
+        internal <#=fullReturnType#> HandleReverseOperationImplementation(BinaryOperation operation, <#=otherColumnType#> right, bool inPlace = false)
         {
             var newColumn = inPlace ? this : (<#=fullReturnType#>)Clone();
             newColumn.ColumnContainer.HandleReverseOperation(operation, right);
@@ -122,7 +122,7 @@ void GenerateAllComparisonCombinationsForMethods()
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, column.ColumnContainer));
         }
 
-        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonScalarOperation operation, <#=otherColumnType#> value)
+        internal BooleanDataFrameColumn HandleOperationImplementation(ComparisonOperation operation, <#=otherColumnType#> value)
         {
             return new BooleanDataFrameColumn(Name, ColumnContainer.HandleOperation(operation, value));
         }
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs
index 40e395e61c..96d1c13c8e 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs
@@ -52,23 +52,6 @@ public override DataFrameColumn Add(DataFrameColumn column, bool inPlace = false
                     throw new NotSupportedException();
             }
         }
-
-        /// <inheritdoc/>
-        public override DataFrameColumn Add<U>(U value, bool inPlace = false)
-        {
-            DataFrameColumn column = value as DataFrameColumn;
-            if (column != null)
-            {
-                return Add(column, 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)
         {
@@ -107,23 +90,6 @@ public override DataFrameColumn Subtract(DataFrameColumn column, bool inPlace =
                     throw new NotSupportedException();
             }
         }
-
-        /// <inheritdoc/>
-        public override DataFrameColumn Subtract<U>(U value, bool inPlace = false)
-        {
-            DataFrameColumn column = value as DataFrameColumn;
-            if (column != null)
-            {
-                return Subtract(column, 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)
         {
@@ -162,23 +128,6 @@ public override DataFrameColumn Multiply(DataFrameColumn column, bool inPlace =
                     throw new NotSupportedException();
             }
         }
-
-        /// <inheritdoc/>
-        public override DataFrameColumn Multiply<U>(U value, bool inPlace = false)
-        {
-            DataFrameColumn column = value as DataFrameColumn;
-            if (column != null)
-            {
-                return Multiply(column, 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)
         {
@@ -217,23 +166,6 @@ public override DataFrameColumn Divide(DataFrameColumn column, bool inPlace = fa
                     throw new NotSupportedException();
             }
         }
-
-        /// <inheritdoc/>
-        public override DataFrameColumn Divide<U>(U value, bool inPlace = false)
-        {
-            DataFrameColumn column = value as DataFrameColumn;
-            if (column != null)
-            {
-                return Divide(column, 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)
         {
@@ -272,23 +204,6 @@ public override DataFrameColumn Modulo(DataFrameColumn column, bool inPlace = fa
                     throw new NotSupportedException();
             }
         }
-
-        /// <inheritdoc/>
-        public override DataFrameColumn Modulo<U>(U value, bool inPlace = false)
-        {
-            DataFrameColumn column = value as DataFrameColumn;
-            if (column != null)
-            {
-                return Modulo(column, 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)
         {
@@ -327,12 +242,6 @@ public override DataFrameColumn And(DataFrameColumn column, bool inPlace = false
                     throw new NotSupportedException();
             }
         }
-
-        /// <inheritdoc/>
-        public override PrimitiveDataFrameColumn<bool> And(bool value, bool inPlace = false)
-        {
-            return HandleBitwiseOperationImplementation(BinaryScalarOperation.And, value, inPlace);
-        }
         /// <inheritdoc/>
         public override DataFrameColumn Or(DataFrameColumn column, bool inPlace = false)
         {
@@ -371,12 +280,6 @@ public override DataFrameColumn Or(DataFrameColumn column, bool inPlace = false)
                     throw new NotSupportedException();
             }
         }
-
-        /// <inheritdoc/>
-        public override PrimitiveDataFrameColumn<bool> Or(bool value, bool inPlace = false)
-        {
-            return HandleBitwiseOperationImplementation(BinaryScalarOperation.Or, value, inPlace);
-        }
         /// <inheritdoc/>
         public override DataFrameColumn Xor(DataFrameColumn column, bool inPlace = false)
         {
@@ -416,10 +319,108 @@ public override DataFrameColumn Xor(DataFrameColumn column, bool inPlace = false
             }
         }
 
+
+        /// <inheritdoc/>
+        public override DataFrameColumn Add<U>(U value, bool inPlace = false)
+        {
+            DataFrameColumn column = value as DataFrameColumn;
+            if (column != null)
+            {
+                return Add(column, inPlace);
+            }
+            return HandleOperationImplementation(BinaryOperation.Add, value, inPlace);
+        }
+
+        /// <inheritdoc/>
+        public override DataFrameColumn ReverseAdd<U>(U value, bool inPlace = false)
+        {
+            return HandleReverseOperationImplementation(BinaryOperation.Add, value, inPlace);
+        }
+
+        /// <inheritdoc/>
+        public override DataFrameColumn Subtract<U>(U value, bool inPlace = false)
+        {
+            DataFrameColumn column = value as DataFrameColumn;
+            if (column != null)
+            {
+                return Subtract(column, inPlace);
+            }
+            return HandleOperationImplementation(BinaryOperation.Subtract, value, inPlace);
+        }
+
+        /// <inheritdoc/>
+        public override DataFrameColumn ReverseSubtract<U>(U value, bool inPlace = false)
+        {
+            return HandleReverseOperationImplementation(BinaryOperation.Subtract, value, inPlace);
+        }
+
+        /// <inheritdoc/>
+        public override DataFrameColumn Multiply<U>(U value, bool inPlace = false)
+        {
+            DataFrameColumn column = value as DataFrameColumn;
+            if (column != null)
+            {
+                return Multiply(column, inPlace);
+            }
+            return HandleOperationImplementation(BinaryOperation.Multiply, value, inPlace);
+        }
+
+        /// <inheritdoc/>
+        public override DataFrameColumn ReverseMultiply<U>(U value, bool inPlace = false)
+        {
+            return HandleReverseOperationImplementation(BinaryOperation.Multiply, value, inPlace);
+        }
+
+        /// <inheritdoc/>
+        public override DataFrameColumn Divide<U>(U value, bool inPlace = false)
+        {
+            DataFrameColumn column = value as DataFrameColumn;
+            if (column != null)
+            {
+                return Divide(column, inPlace);
+            }
+            return HandleOperationImplementation(BinaryOperation.Divide, value, inPlace);
+        }
+
+        /// <inheritdoc/>
+        public override DataFrameColumn ReverseDivide<U>(U value, bool inPlace = false)
+        {
+            return HandleReverseOperationImplementation(BinaryOperation.Divide, value, inPlace);
+        }
+
+        /// <inheritdoc/>
+        public override DataFrameColumn Modulo<U>(U value, bool inPlace = false)
+        {
+            DataFrameColumn column = value as DataFrameColumn;
+            if (column != null)
+            {
+                return Modulo(column, inPlace);
+            }
+            return HandleOperationImplementation(BinaryOperation.Modulo, value, inPlace);
+        }
+
+        /// <inheritdoc/>
+        public override DataFrameColumn ReverseModulo<U>(U value, bool inPlace = false)
+        {
+            return HandleReverseOperationImplementation(BinaryOperation.Modulo, value, inPlace);
+        }
+
+        /// <inheritdoc/>
+        public override PrimitiveDataFrameColumn<bool> And(bool value, bool inPlace = false)
+        {
+            return HandleBitwiseOperationImplementation(BinaryOperation.And, value, inPlace);
+        }
+
+        /// <inheritdoc/>
+        public override PrimitiveDataFrameColumn<bool> Or(bool value, bool inPlace = false)
+        {
+            return HandleBitwiseOperationImplementation(BinaryOperation.Or, value, inPlace);
+        }
+
         /// <inheritdoc/>
         public override PrimitiveDataFrameColumn<bool> Xor(bool value, bool inPlace = false)
         {
-            return HandleBitwiseOperationImplementation(BinaryScalarOperation.Xor, value, inPlace);
+            return HandleBitwiseOperationImplementation(BinaryOperation.Xor, value, inPlace);
         }
 
         /// <inheritdoc/>
@@ -483,7 +484,7 @@ public override PrimitiveDataFrameColumn<bool> ElementwiseEquals<U>(U value)
             {
                 return ElementwiseEquals(column);
             }
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseEquals, value);
         }
 
         /// <inheritdoc/>
@@ -535,7 +536,7 @@ public override PrimitiveDataFrameColumn<bool> ElementwiseNotEquals<U>(U value)
             {
                 return ElementwiseNotEquals(column);
             }
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseNotEquals, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseNotEquals, value);
         }
 
         /// <inheritdoc/>
@@ -585,7 +586,7 @@ public override PrimitiveDataFrameColumn<bool> ElementwiseGreaterThanOrEqual<U>(
             {
                 return ElementwiseGreaterThanOrEqual(column);
             }
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThanOrEqual, value);
         }
 
         /// <inheritdoc/>
@@ -635,7 +636,7 @@ public override PrimitiveDataFrameColumn<bool> ElementwiseLessThanOrEqual<U>(U v
             {
                 return ElementwiseLessThanOrEqual(column);
             }
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThanOrEqual, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThanOrEqual, value);
         }
 
         /// <inheritdoc/>
@@ -685,7 +686,7 @@ public override PrimitiveDataFrameColumn<bool> ElementwiseGreaterThan<U>(U value
             {
                 return ElementwiseGreaterThan(column);
             }
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseGreaterThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseGreaterThan, value);
         }
 
         /// <inheritdoc/>
@@ -735,7 +736,7 @@ public override PrimitiveDataFrameColumn<bool> ElementwiseLessThan<U>(U value)
             {
                 return ElementwiseLessThan(column);
             }
-            return HandleOperationImplementation(ComparisonScalarOperation.ElementwiseLessThan, value);
+            return HandleOperationImplementation(ComparisonOperation.ElementwiseLessThan, value);
         }
 
     }
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt
index 320fd2c455..f3f0c56883 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt
@@ -68,7 +68,7 @@ namespace Microsoft.Data.Analysis
         /// <inheritdoc/>
         public override PrimitiveDataFrameColumn<bool> <#=method.MethodName#>(bool value, bool inPlace = false)
         {
-            return HandleBitwiseOperationImplementation(BinaryScalarOperation.<#=method.MethodName#>, value, inPlace);
+            return HandleBitwiseOperationImplementation(BinaryOperation.<#=method.MethodName#>, value, inPlace);
         }
 <# } else { #>
 
@@ -80,13 +80,13 @@ namespace Microsoft.Data.Analysis
             {
                 return <#=method.MethodName#>(column, inPlace);
             }
-            return HandleOperationImplementation(BinaryScalarOperation.<#=method.MethodName#>, value, inPlace);
+            return HandleOperationImplementation(BinaryOperation.<#=method.MethodName#>, value, inPlace);
         }
 
         /// <inheritdoc/>
         public override DataFrameColumn Reverse<#=method.MethodName#><U>(U value, bool inPlace = false)
         {
-            return HandleReverseOperationImplementation(BinaryScalarOperation.<#=method.MethodName#>, value, inPlace);
+            return HandleReverseOperationImplementation(BinaryOperation.<#=method.MethodName#>, value, inPlace);
         }
 <# } #>
 <# } #>
@@ -100,7 +100,7 @@ namespace Microsoft.Data.Analysis
             {
                 return <#=method.MethodName#>(column);
             }
-            return HandleOperationImplementation(ComparisonScalarOperation.<#=method.MethodName#>, value);
+            return HandleOperationImplementation(ComparisonOperation.<#=method.MethodName#>, value);
         }
 <# } #>
 <# if (method.MethodType == MethodType.BinaryInt ) {#>
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.Computations.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.Computations.tt
index 763762c4b4..e6e09804aa 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.Computations.tt
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.Computations.tt
@@ -43,11 +43,11 @@ namespace Microsoft.Data.Analysis
 <# } #>
         {
 <# if (compMethod.MethodType == MethodType.ElementwiseComputation && compMethod.HasReturnValue == false && compMethod.SupportsRowSubsets == true) {#>
-            PrimitiveDataFrameColumn<T> ret = <#=GenerateInPlaceStatement("this", "Clone()")#>;
+            PrimitiveDataFrameColumn<T> ret = inPlace ? this : Clone();
             PrimitiveColumnComputation<T>.Instance.<#=compMethod.MethodName#>(ret._columnContainer, rowIndices);
             return ret;
 <# } else if (compMethod.MethodType == MethodType.ElementwiseComputation && compMethod.HasReturnValue == false) {#>
-            PrimitiveDataFrameColumn<T> ret = <#=GenerateInPlaceStatement("this", "Clone()")#>;
+            PrimitiveDataFrameColumn<T> ret = inPlace ? this : Clone();
             PrimitiveColumnComputation<T>.Instance.<#=compMethod.MethodName#>(ret._columnContainer);
             return ret;
 <# } else if (compMethod.MethodType == MethodType.ElementwiseComputation && compMethod.HasReturnValue == true) {#>
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs
index 6fe5270de4..8a8c088e67 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.cs
@@ -975,7 +975,7 @@ internal DataFrameColumn HandleOperationImplementation<U>(BinaryOperation operat
             }
         }
 
-        internal DataFrameColumn HandleOperationImplementation<U>(BinaryScalarOperation operation, U value, bool inPlace)
+        internal DataFrameColumn HandleOperationImplementation<U>(BinaryOperation operation, U value, bool inPlace)
         {
             switch (typeof(T))
             {
@@ -1053,7 +1053,7 @@ internal DataFrameColumn HandleOperationImplementation<U>(BinaryScalarOperation
             }
         }
 
-        internal DataFrameColumn HandleReverseOperationImplementation<U>(BinaryScalarOperation operation, U value, bool inPlace = false)
+        internal DataFrameColumn HandleReverseOperationImplementation<U>(BinaryOperation operation, U value, bool inPlace = false)
         {
             switch (typeof(T))
             {
@@ -1129,7 +1129,7 @@ internal DataFrameColumn HandleReverseOperationImplementation<U>(BinaryScalarOpe
             }
         }
 
-        internal PrimitiveDataFrameColumn<bool> HandleBitwiseOperationImplementation<U>(BinaryScalarOperation operation, U value, bool inPlace)
+        internal PrimitiveDataFrameColumn<bool> HandleBitwiseOperationImplementation<U>(BinaryOperation operation, U value, bool inPlace)
         {
             switch (typeof(T))
             {
@@ -1142,19 +1142,7 @@ internal PrimitiveDataFrameColumn<bool> HandleBitwiseOperationImplementation<U>(
                     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();
             }
@@ -1300,7 +1288,7 @@ internal PrimitiveDataFrameColumn<bool> HandleOperationImplementation<U>(Compari
             }
         }
 
-        internal PrimitiveDataFrameColumn<bool> HandleOperationImplementation<U>(ComparisonScalarOperation operation, U value)
+        internal PrimitiveDataFrameColumn<bool> HandleOperationImplementation<U>(ComparisonOperation operation, U value)
         {
             switch (typeof(T))
             {
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs
deleted file mode 100644
index b43addb421..0000000000
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs
+++ /dev/null
@@ -1,3319 +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 PrimitiveDataFrameColumnArithmetic.tt. Do not modify directly
-
-using System;
-
-namespace Microsoft.Data.Analysis
-{
-    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;
-            }
-            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();
-
-    }
-
-    internal static class PrimitiveDataFrameColumnArithmetic
-    {
-        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>
-    {
-
-        protected override void And(Span<bool> left, ReadOnlySpan<bool> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (bool)(left[i] & right[i]);
-        }
-
-        protected override void And(Span<bool> left, bool right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (bool)(left[i] & right);
-        }
-
-        protected override void And(bool left, Span<bool> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (bool)(left & right[i]);
-        }
-
-        protected override void Or(Span<bool> left, ReadOnlySpan<bool> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (bool)(left[i] | right[i]);
-        }
-
-        protected override void Or(Span<bool> left, bool right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (bool)(left[i] | right);
-        }
-
-        protected override void Or(bool left, Span<bool> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (bool)(left | right[i]);
-        }
-
-        protected override void Xor(Span<bool> left, ReadOnlySpan<bool> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (bool)(left[i] ^ right[i]);
-        }
-
-        protected override void Xor(Span<bool> left, bool right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (bool)(left[i] ^ right);
-        }
-
-        protected override void Xor(bool left, Span<bool> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (bool)(left ^ right[i]);
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<bool> left, ReadOnlySpan<bool> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right[i]);
-            }
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<bool> left, bool right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<bool> left, ReadOnlySpan<bool> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right[i]);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<bool> left, bool right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right);
-            }
-        }
-    }
-    internal class ByteArithmetic : PrimitiveDataFrameColumnArithmetic<byte>
-    {
-
-        protected override void Add(Span<byte> left, ReadOnlySpan<byte> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (byte)(left[i] + right[i]);
-        }
-
-        protected override void Add(Span<byte> left, byte right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (byte)(left[i] + right);
-        }
-
-        protected override void Add(byte left, Span<byte> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (byte)(left + right[i]);
-        }
-
-        protected override void Subtract(Span<byte> left, ReadOnlySpan<byte> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (byte)(left[i] - right[i]);
-        }
-
-        protected override void Subtract(Span<byte> left, byte right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (byte)(left[i] - right);
-        }
-
-        protected override void Subtract(byte left, Span<byte> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (byte)(left - right[i]);
-        }
-
-        protected override void Multiply(Span<byte> left, ReadOnlySpan<byte> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (byte)(left[i] * right[i]);
-        }
-
-        protected override void Multiply(Span<byte> left, byte right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (byte)(left[i] * right);
-        }
-
-        protected override void Multiply(byte left, Span<byte> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (byte)(left * right[i]);
-        }
-
-        protected override void Divide(Span<byte> left, Span<byte> leftValidity, ReadOnlySpan<byte> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    left[i] = (byte)(left[i] / right[i]);
-                else
-                    BitUtility.ClearBit(leftValidity, i);
-            }
-        }
-
-        protected override void Divide(Span<byte> left, byte right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (byte)(left[i] / right);
-        }
-
-        protected override void Divide(byte left, Span<byte> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < right.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    right[i] = (byte)(left / right[i]);
-            }
-        }
-
-        protected override void Modulo(Span<byte> left, ReadOnlySpan<byte> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (byte)(left[i] % right[i]);
-        }
-
-        protected override void Modulo(Span<byte> left, byte right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (byte)(left[i] % right);
-        }
-
-        protected override void Modulo(byte left, Span<byte> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (byte)(left % right[i]);
-        }
-
-        protected override void And(Span<byte> left, ReadOnlySpan<byte> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (byte)(left[i] & right[i]);
-        }
-
-        protected override void And(Span<byte> left, byte right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (byte)(left[i] & right);
-        }
-
-        protected override void And(byte left, Span<byte> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (byte)(left & right[i]);
-        }
-
-        protected override void Or(Span<byte> left, ReadOnlySpan<byte> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (byte)(left[i] | right[i]);
-        }
-
-        protected override void Or(Span<byte> left, byte right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (byte)(left[i] | right);
-        }
-
-        protected override void Or(byte left, Span<byte> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (byte)(left | right[i]);
-        }
-
-        protected override void Xor(Span<byte> left, ReadOnlySpan<byte> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (byte)(left[i] ^ right[i]);
-        }
-
-        protected override void Xor(Span<byte> left, byte right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (byte)(left[i] ^ right);
-        }
-
-        protected override void Xor(byte left, Span<byte> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (byte)(left ^ right[i]);
-        }
-
-        protected override void LeftShift(Span<byte> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (byte)(left[i] << right);
-        }
-
-        protected override void RightShift(Span<byte> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (byte)(left[i] >> right);
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<byte> left, ReadOnlySpan<byte> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right[i]);
-            }
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<byte> left, byte right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<byte> left, ReadOnlySpan<byte> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right[i]);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<byte> left, byte right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<byte> left, ReadOnlySpan<byte> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<byte> left, byte right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<byte> left, ReadOnlySpan<byte> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<byte> left, byte right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<byte> left, ReadOnlySpan<byte> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<byte> left, byte right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<byte> left, ReadOnlySpan<byte> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<byte> left, byte right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right);
-            }
-        }
-    }
-    internal class CharArithmetic : PrimitiveDataFrameColumnArithmetic<char>
-    {
-
-        protected override void Add(Span<char> left, ReadOnlySpan<char> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (char)(left[i] + right[i]);
-        }
-
-        protected override void Add(Span<char> left, char right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (char)(left[i] + right);
-        }
-
-        protected override void Add(char left, Span<char> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (char)(left + right[i]);
-        }
-
-        protected override void Subtract(Span<char> left, ReadOnlySpan<char> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (char)(left[i] - right[i]);
-        }
-
-        protected override void Subtract(Span<char> left, char right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (char)(left[i] - right);
-        }
-
-        protected override void Subtract(char left, Span<char> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (char)(left - right[i]);
-        }
-
-        protected override void Multiply(Span<char> left, ReadOnlySpan<char> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (char)(left[i] * right[i]);
-        }
-
-        protected override void Multiply(Span<char> left, char right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (char)(left[i] * right);
-        }
-
-        protected override void Multiply(char left, Span<char> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (char)(left * right[i]);
-        }
-
-        protected override void Divide(Span<char> left, Span<byte> leftValidity, ReadOnlySpan<char> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    left[i] = (char)(left[i] / right[i]);
-                else
-                    BitUtility.ClearBit(leftValidity, i);
-            }
-        }
-
-        protected override void Divide(Span<char> left, char right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (char)(left[i] / right);
-        }
-
-        protected override void Divide(char left, Span<char> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < right.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    right[i] = (char)(left / right[i]);
-            }
-        }
-
-        protected override void Modulo(Span<char> left, ReadOnlySpan<char> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (char)(left[i] % right[i]);
-        }
-
-        protected override void Modulo(Span<char> left, char right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (char)(left[i] % right);
-        }
-
-        protected override void Modulo(char left, Span<char> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (char)(left % right[i]);
-        }
-
-        protected override void And(Span<char> left, ReadOnlySpan<char> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (char)(left[i] & right[i]);
-        }
-
-        protected override void And(Span<char> left, char right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (char)(left[i] & right);
-        }
-
-        protected override void And(char left, Span<char> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (char)(left & right[i]);
-        }
-
-        protected override void Or(Span<char> left, ReadOnlySpan<char> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (char)(left[i] | right[i]);
-        }
-
-        protected override void Or(Span<char> left, char right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (char)(left[i] | right);
-        }
-
-        protected override void Or(char left, Span<char> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (char)(left | right[i]);
-        }
-
-        protected override void Xor(Span<char> left, ReadOnlySpan<char> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (char)(left[i] ^ right[i]);
-        }
-
-        protected override void Xor(Span<char> left, char right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (char)(left[i] ^ right);
-        }
-
-        protected override void Xor(char left, Span<char> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (char)(left ^ right[i]);
-        }
-
-        protected override void LeftShift(Span<char> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (char)(left[i] << right);
-        }
-
-        protected override void RightShift(Span<char> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (char)(left[i] >> right);
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<char> left, ReadOnlySpan<char> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right[i]);
-            }
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<char> left, char right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<char> left, ReadOnlySpan<char> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right[i]);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<char> left, char right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<char> left, ReadOnlySpan<char> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<char> left, char right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<char> left, ReadOnlySpan<char> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<char> left, char right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<char> left, ReadOnlySpan<char> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<char> left, char right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<char> left, ReadOnlySpan<char> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<char> left, char right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right);
-            }
-        }
-    }
-    internal class DecimalArithmetic : PrimitiveDataFrameColumnArithmetic<decimal>
-    {
-
-        protected override void Add(Span<decimal> left, ReadOnlySpan<decimal> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (decimal)(left[i] + right[i]);
-        }
-
-        protected override void Add(Span<decimal> left, decimal right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (decimal)(left[i] + right);
-        }
-
-        protected override void Add(decimal left, Span<decimal> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (decimal)(left + right[i]);
-        }
-
-        protected override void Subtract(Span<decimal> left, ReadOnlySpan<decimal> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (decimal)(left[i] - right[i]);
-        }
-
-        protected override void Subtract(Span<decimal> left, decimal right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (decimal)(left[i] - right);
-        }
-
-        protected override void Subtract(decimal left, Span<decimal> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (decimal)(left - right[i]);
-        }
-
-        protected override void Multiply(Span<decimal> left, ReadOnlySpan<decimal> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (decimal)(left[i] * right[i]);
-        }
-
-        protected override void Multiply(Span<decimal> left, decimal right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (decimal)(left[i] * right);
-        }
-
-        protected override void Multiply(decimal left, Span<decimal> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (decimal)(left * right[i]);
-        }
-
-        protected override void Divide(Span<decimal> left, Span<byte> leftValidity, ReadOnlySpan<decimal> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    left[i] = (decimal)(left[i] / right[i]);
-                else
-                    BitUtility.ClearBit(leftValidity, i);
-            }
-        }
-
-        protected override void Divide(Span<decimal> left, decimal right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (decimal)(left[i] / right);
-        }
-
-        protected override void Divide(decimal left, Span<decimal> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < right.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    right[i] = (decimal)(left / right[i]);
-            }
-        }
-
-        protected override void Modulo(Span<decimal> left, ReadOnlySpan<decimal> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (decimal)(left[i] % right[i]);
-        }
-
-        protected override void Modulo(Span<decimal> left, decimal right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (decimal)(left[i] % right);
-        }
-
-        protected override void Modulo(decimal left, Span<decimal> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (decimal)(left % right[i]);
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<decimal> left, ReadOnlySpan<decimal> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right[i]);
-            }
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<decimal> left, decimal right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<decimal> left, ReadOnlySpan<decimal> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right[i]);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<decimal> left, decimal right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<decimal> left, ReadOnlySpan<decimal> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<decimal> left, decimal right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<decimal> left, ReadOnlySpan<decimal> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<decimal> left, decimal right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<decimal> left, ReadOnlySpan<decimal> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<decimal> left, decimal right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<decimal> left, ReadOnlySpan<decimal> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<decimal> left, decimal right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right);
-            }
-        }
-    }
-    internal class DoubleArithmetic : PrimitiveDataFrameColumnArithmetic<double>
-    {
-
-        protected override void Add(Span<double> left, ReadOnlySpan<double> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (double)(left[i] + right[i]);
-        }
-
-        protected override void Add(Span<double> left, double right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (double)(left[i] + right);
-        }
-
-        protected override void Add(double left, Span<double> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (double)(left + right[i]);
-        }
-
-        protected override void Subtract(Span<double> left, ReadOnlySpan<double> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (double)(left[i] - right[i]);
-        }
-
-        protected override void Subtract(Span<double> left, double right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (double)(left[i] - right);
-        }
-
-        protected override void Subtract(double left, Span<double> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (double)(left - right[i]);
-        }
-
-        protected override void Multiply(Span<double> left, ReadOnlySpan<double> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (double)(left[i] * right[i]);
-        }
-
-        protected override void Multiply(Span<double> left, double right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (double)(left[i] * right);
-        }
-
-        protected override void Multiply(double left, Span<double> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (double)(left * right[i]);
-        }
-
-        protected override void Divide(Span<double> left, Span<byte> leftValidity, ReadOnlySpan<double> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    left[i] = (double)(left[i] / right[i]);
-                else
-                    BitUtility.ClearBit(leftValidity, i);
-            }
-        }
-
-        protected override void Divide(Span<double> left, double right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (double)(left[i] / right);
-        }
-
-        protected override void Divide(double left, Span<double> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < right.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    right[i] = (double)(left / right[i]);
-            }
-        }
-
-        protected override void Modulo(Span<double> left, ReadOnlySpan<double> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (double)(left[i] % right[i]);
-        }
-
-        protected override void Modulo(Span<double> left, double right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (double)(left[i] % right);
-        }
-
-        protected override void Modulo(double left, Span<double> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (double)(left % right[i]);
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<double> left, ReadOnlySpan<double> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right[i]);
-            }
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<double> left, double right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<double> left, ReadOnlySpan<double> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right[i]);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<double> left, double right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<double> left, ReadOnlySpan<double> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<double> left, double right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<double> left, ReadOnlySpan<double> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<double> left, double right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<double> left, ReadOnlySpan<double> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<double> left, double right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<double> left, ReadOnlySpan<double> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<double> left, double right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right);
-            }
-        }
-    }
-    internal class FloatArithmetic : PrimitiveDataFrameColumnArithmetic<float>
-    {
-
-        protected override void Add(Span<float> left, ReadOnlySpan<float> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (float)(left[i] + right[i]);
-        }
-
-        protected override void Add(Span<float> left, float right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (float)(left[i] + right);
-        }
-
-        protected override void Add(float left, Span<float> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (float)(left + right[i]);
-        }
-
-        protected override void Subtract(Span<float> left, ReadOnlySpan<float> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (float)(left[i] - right[i]);
-        }
-
-        protected override void Subtract(Span<float> left, float right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (float)(left[i] - right);
-        }
-
-        protected override void Subtract(float left, Span<float> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (float)(left - right[i]);
-        }
-
-        protected override void Multiply(Span<float> left, ReadOnlySpan<float> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (float)(left[i] * right[i]);
-        }
-
-        protected override void Multiply(Span<float> left, float right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (float)(left[i] * right);
-        }
-
-        protected override void Multiply(float left, Span<float> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (float)(left * right[i]);
-        }
-
-        protected override void Divide(Span<float> left, Span<byte> leftValidity, ReadOnlySpan<float> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    left[i] = (float)(left[i] / right[i]);
-                else
-                    BitUtility.ClearBit(leftValidity, i);
-            }
-        }
-
-        protected override void Divide(Span<float> left, float right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (float)(left[i] / right);
-        }
-
-        protected override void Divide(float left, Span<float> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < right.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    right[i] = (float)(left / right[i]);
-            }
-        }
-
-        protected override void Modulo(Span<float> left, ReadOnlySpan<float> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (float)(left[i] % right[i]);
-        }
-
-        protected override void Modulo(Span<float> left, float right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (float)(left[i] % right);
-        }
-
-        protected override void Modulo(float left, Span<float> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (float)(left % right[i]);
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<float> left, ReadOnlySpan<float> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right[i]);
-            }
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<float> left, float right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<float> left, ReadOnlySpan<float> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right[i]);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<float> left, float right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<float> left, ReadOnlySpan<float> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<float> left, float right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<float> left, ReadOnlySpan<float> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<float> left, float right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<float> left, ReadOnlySpan<float> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<float> left, float right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<float> left, ReadOnlySpan<float> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<float> left, float right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right);
-            }
-        }
-    }
-    internal class IntArithmetic : PrimitiveDataFrameColumnArithmetic<int>
-    {
-
-        protected override void Add(Span<int> left, ReadOnlySpan<int> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (int)(left[i] + right[i]);
-        }
-
-        protected override void Add(Span<int> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (int)(left[i] + right);
-        }
-
-        protected override void Add(int left, Span<int> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (int)(left + right[i]);
-        }
-
-        protected override void Subtract(Span<int> left, ReadOnlySpan<int> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (int)(left[i] - right[i]);
-        }
-
-        protected override void Subtract(Span<int> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (int)(left[i] - right);
-        }
-
-        protected override void Subtract(int left, Span<int> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (int)(left - right[i]);
-        }
-
-        protected override void Multiply(Span<int> left, ReadOnlySpan<int> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (int)(left[i] * right[i]);
-        }
-
-        protected override void Multiply(Span<int> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (int)(left[i] * right);
-        }
-
-        protected override void Multiply(int left, Span<int> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (int)(left * right[i]);
-        }
-
-        protected override void Divide(Span<int> left, Span<byte> leftValidity, ReadOnlySpan<int> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    left[i] = (int)(left[i] / right[i]);
-                else
-                    BitUtility.ClearBit(leftValidity, i);
-            }
-        }
-
-        protected override void Divide(Span<int> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (int)(left[i] / right);
-        }
-
-        protected override void Divide(int left, Span<int> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < right.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    right[i] = (int)(left / right[i]);
-            }
-        }
-
-        protected override void Modulo(Span<int> left, ReadOnlySpan<int> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (int)(left[i] % right[i]);
-        }
-
-        protected override void Modulo(Span<int> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (int)(left[i] % right);
-        }
-
-        protected override void Modulo(int left, Span<int> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (int)(left % right[i]);
-        }
-
-        protected override void And(Span<int> left, ReadOnlySpan<int> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (int)(left[i] & right[i]);
-        }
-
-        protected override void And(Span<int> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (int)(left[i] & right);
-        }
-
-        protected override void And(int left, Span<int> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (int)(left & right[i]);
-        }
-
-        protected override void Or(Span<int> left, ReadOnlySpan<int> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (int)(left[i] | right[i]);
-        }
-
-        protected override void Or(Span<int> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (int)(left[i] | right);
-        }
-
-        protected override void Or(int left, Span<int> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (int)(left | right[i]);
-        }
-
-        protected override void Xor(Span<int> left, ReadOnlySpan<int> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (int)(left[i] ^ right[i]);
-        }
-
-        protected override void Xor(Span<int> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (int)(left[i] ^ right);
-        }
-
-        protected override void Xor(int left, Span<int> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (int)(left ^ right[i]);
-        }
-
-        protected override void LeftShift(Span<int> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (int)(left[i] << right);
-        }
-
-        protected override void RightShift(Span<int> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (int)(left[i] >> right);
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<int> left, ReadOnlySpan<int> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right[i]);
-            }
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<int> left, int right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<int> left, ReadOnlySpan<int> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right[i]);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<int> left, int right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<int> left, ReadOnlySpan<int> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<int> left, int right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<int> left, ReadOnlySpan<int> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<int> left, int right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<int> left, ReadOnlySpan<int> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<int> left, int right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<int> left, ReadOnlySpan<int> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<int> left, int right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right);
-            }
-        }
-    }
-    internal class LongArithmetic : PrimitiveDataFrameColumnArithmetic<long>
-    {
-
-        protected override void Add(Span<long> left, ReadOnlySpan<long> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (long)(left[i] + right[i]);
-        }
-
-        protected override void Add(Span<long> left, long right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (long)(left[i] + right);
-        }
-
-        protected override void Add(long left, Span<long> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (long)(left + right[i]);
-        }
-
-        protected override void Subtract(Span<long> left, ReadOnlySpan<long> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (long)(left[i] - right[i]);
-        }
-
-        protected override void Subtract(Span<long> left, long right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (long)(left[i] - right);
-        }
-
-        protected override void Subtract(long left, Span<long> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (long)(left - right[i]);
-        }
-
-        protected override void Multiply(Span<long> left, ReadOnlySpan<long> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (long)(left[i] * right[i]);
-        }
-
-        protected override void Multiply(Span<long> left, long right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (long)(left[i] * right);
-        }
-
-        protected override void Multiply(long left, Span<long> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (long)(left * right[i]);
-        }
-
-        protected override void Divide(Span<long> left, Span<byte> leftValidity, ReadOnlySpan<long> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    left[i] = (long)(left[i] / right[i]);
-                else
-                    BitUtility.ClearBit(leftValidity, i);
-            }
-        }
-
-        protected override void Divide(Span<long> left, long right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (long)(left[i] / right);
-        }
-
-        protected override void Divide(long left, Span<long> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < right.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    right[i] = (long)(left / right[i]);
-            }
-        }
-
-        protected override void Modulo(Span<long> left, ReadOnlySpan<long> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (long)(left[i] % right[i]);
-        }
-
-        protected override void Modulo(Span<long> left, long right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (long)(left[i] % right);
-        }
-
-        protected override void Modulo(long left, Span<long> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (long)(left % right[i]);
-        }
-
-        protected override void And(Span<long> left, ReadOnlySpan<long> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (long)(left[i] & right[i]);
-        }
-
-        protected override void And(Span<long> left, long right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (long)(left[i] & right);
-        }
-
-        protected override void And(long left, Span<long> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (long)(left & right[i]);
-        }
-
-        protected override void Or(Span<long> left, ReadOnlySpan<long> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (long)(left[i] | right[i]);
-        }
-
-        protected override void Or(Span<long> left, long right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (long)(left[i] | right);
-        }
-
-        protected override void Or(long left, Span<long> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (long)(left | right[i]);
-        }
-
-        protected override void Xor(Span<long> left, ReadOnlySpan<long> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (long)(left[i] ^ right[i]);
-        }
-
-        protected override void Xor(Span<long> left, long right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (long)(left[i] ^ right);
-        }
-
-        protected override void Xor(long left, Span<long> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (long)(left ^ right[i]);
-        }
-
-        protected override void LeftShift(Span<long> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (long)(left[i] << right);
-        }
-
-        protected override void RightShift(Span<long> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (long)(left[i] >> right);
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<long> left, ReadOnlySpan<long> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right[i]);
-            }
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<long> left, long right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<long> left, ReadOnlySpan<long> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right[i]);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<long> left, long right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<long> left, ReadOnlySpan<long> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<long> left, long right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<long> left, ReadOnlySpan<long> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<long> left, long right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<long> left, ReadOnlySpan<long> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<long> left, long right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<long> left, ReadOnlySpan<long> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<long> left, long right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right);
-            }
-        }
-    }
-    internal class SByteArithmetic : PrimitiveDataFrameColumnArithmetic<sbyte>
-    {
-
-        protected override void Add(Span<sbyte> left, ReadOnlySpan<sbyte> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (sbyte)(left[i] + right[i]);
-        }
-
-        protected override void Add(Span<sbyte> left, sbyte right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (sbyte)(left[i] + right);
-        }
-
-        protected override void Add(sbyte left, Span<sbyte> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (sbyte)(left + right[i]);
-        }
-
-        protected override void Subtract(Span<sbyte> left, ReadOnlySpan<sbyte> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (sbyte)(left[i] - right[i]);
-        }
-
-        protected override void Subtract(Span<sbyte> left, sbyte right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (sbyte)(left[i] - right);
-        }
-
-        protected override void Subtract(sbyte left, Span<sbyte> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (sbyte)(left - right[i]);
-        }
-
-        protected override void Multiply(Span<sbyte> left, ReadOnlySpan<sbyte> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (sbyte)(left[i] * right[i]);
-        }
-
-        protected override void Multiply(Span<sbyte> left, sbyte right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (sbyte)(left[i] * right);
-        }
-
-        protected override void Multiply(sbyte left, Span<sbyte> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (sbyte)(left * right[i]);
-        }
-
-        protected override void Divide(Span<sbyte> left, Span<byte> leftValidity, ReadOnlySpan<sbyte> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    left[i] = (sbyte)(left[i] / right[i]);
-                else
-                    BitUtility.ClearBit(leftValidity, i);
-            }
-        }
-
-        protected override void Divide(Span<sbyte> left, sbyte right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (sbyte)(left[i] / right);
-        }
-
-        protected override void Divide(sbyte left, Span<sbyte> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < right.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    right[i] = (sbyte)(left / right[i]);
-            }
-        }
-
-        protected override void Modulo(Span<sbyte> left, ReadOnlySpan<sbyte> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (sbyte)(left[i] % right[i]);
-        }
-
-        protected override void Modulo(Span<sbyte> left, sbyte right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (sbyte)(left[i] % right);
-        }
-
-        protected override void Modulo(sbyte left, Span<sbyte> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (sbyte)(left % right[i]);
-        }
-
-        protected override void And(Span<sbyte> left, ReadOnlySpan<sbyte> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (sbyte)(left[i] & right[i]);
-        }
-
-        protected override void And(Span<sbyte> left, sbyte right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (sbyte)(left[i] & right);
-        }
-
-        protected override void And(sbyte left, Span<sbyte> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (sbyte)(left & right[i]);
-        }
-
-        protected override void Or(Span<sbyte> left, ReadOnlySpan<sbyte> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (sbyte)(left[i] | right[i]);
-        }
-
-        protected override void Or(Span<sbyte> left, sbyte right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (sbyte)(left[i] | right);
-        }
-
-        protected override void Or(sbyte left, Span<sbyte> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (sbyte)(left | right[i]);
-        }
-
-        protected override void Xor(Span<sbyte> left, ReadOnlySpan<sbyte> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (sbyte)(left[i] ^ right[i]);
-        }
-
-        protected override void Xor(Span<sbyte> left, sbyte right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (sbyte)(left[i] ^ right);
-        }
-
-        protected override void Xor(sbyte left, Span<sbyte> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (sbyte)(left ^ right[i]);
-        }
-
-        protected override void LeftShift(Span<sbyte> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (sbyte)(left[i] << right);
-        }
-
-        protected override void RightShift(Span<sbyte> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (sbyte)(left[i] >> right);
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<sbyte> left, ReadOnlySpan<sbyte> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right[i]);
-            }
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<sbyte> left, sbyte right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<sbyte> left, ReadOnlySpan<sbyte> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right[i]);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<sbyte> left, sbyte right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<sbyte> left, ReadOnlySpan<sbyte> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<sbyte> left, sbyte right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<sbyte> left, ReadOnlySpan<sbyte> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<sbyte> left, sbyte right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<sbyte> left, ReadOnlySpan<sbyte> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<sbyte> left, sbyte right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<sbyte> left, ReadOnlySpan<sbyte> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<sbyte> left, sbyte right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right);
-            }
-        }
-    }
-    internal class ShortArithmetic : PrimitiveDataFrameColumnArithmetic<short>
-    {
-
-        protected override void Add(Span<short> left, ReadOnlySpan<short> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (short)(left[i] + right[i]);
-        }
-
-        protected override void Add(Span<short> left, short right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (short)(left[i] + right);
-        }
-
-        protected override void Add(short left, Span<short> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (short)(left + right[i]);
-        }
-
-        protected override void Subtract(Span<short> left, ReadOnlySpan<short> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (short)(left[i] - right[i]);
-        }
-
-        protected override void Subtract(Span<short> left, short right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (short)(left[i] - right);
-        }
-
-        protected override void Subtract(short left, Span<short> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (short)(left - right[i]);
-        }
-
-        protected override void Multiply(Span<short> left, ReadOnlySpan<short> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (short)(left[i] * right[i]);
-        }
-
-        protected override void Multiply(Span<short> left, short right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (short)(left[i] * right);
-        }
-
-        protected override void Multiply(short left, Span<short> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (short)(left * right[i]);
-        }
-
-        protected override void Divide(Span<short> left, Span<byte> leftValidity, ReadOnlySpan<short> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    left[i] = (short)(left[i] / right[i]);
-                else
-                    BitUtility.ClearBit(leftValidity, i);
-            }
-        }
-
-        protected override void Divide(Span<short> left, short right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (short)(left[i] / right);
-        }
-
-        protected override void Divide(short left, Span<short> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < right.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    right[i] = (short)(left / right[i]);
-            }
-        }
-
-        protected override void Modulo(Span<short> left, ReadOnlySpan<short> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (short)(left[i] % right[i]);
-        }
-
-        protected override void Modulo(Span<short> left, short right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (short)(left[i] % right);
-        }
-
-        protected override void Modulo(short left, Span<short> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (short)(left % right[i]);
-        }
-
-        protected override void And(Span<short> left, ReadOnlySpan<short> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (short)(left[i] & right[i]);
-        }
-
-        protected override void And(Span<short> left, short right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (short)(left[i] & right);
-        }
-
-        protected override void And(short left, Span<short> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (short)(left & right[i]);
-        }
-
-        protected override void Or(Span<short> left, ReadOnlySpan<short> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (short)(left[i] | right[i]);
-        }
-
-        protected override void Or(Span<short> left, short right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (short)(left[i] | right);
-        }
-
-        protected override void Or(short left, Span<short> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (short)(left | right[i]);
-        }
-
-        protected override void Xor(Span<short> left, ReadOnlySpan<short> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (short)(left[i] ^ right[i]);
-        }
-
-        protected override void Xor(Span<short> left, short right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (short)(left[i] ^ right);
-        }
-
-        protected override void Xor(short left, Span<short> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (short)(left ^ right[i]);
-        }
-
-        protected override void LeftShift(Span<short> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (short)(left[i] << right);
-        }
-
-        protected override void RightShift(Span<short> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (short)(left[i] >> right);
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<short> left, ReadOnlySpan<short> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right[i]);
-            }
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<short> left, short right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<short> left, ReadOnlySpan<short> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right[i]);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<short> left, short right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<short> left, ReadOnlySpan<short> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<short> left, short right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<short> left, ReadOnlySpan<short> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<short> left, short right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<short> left, ReadOnlySpan<short> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<short> left, short right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<short> left, ReadOnlySpan<short> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<short> left, short right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right);
-            }
-        }
-    }
-    internal class UIntArithmetic : PrimitiveDataFrameColumnArithmetic<uint>
-    {
-
-        protected override void Add(Span<uint> left, ReadOnlySpan<uint> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (uint)(left[i] + right[i]);
-        }
-
-        protected override void Add(Span<uint> left, uint right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (uint)(left[i] + right);
-        }
-
-        protected override void Add(uint left, Span<uint> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (uint)(left + right[i]);
-        }
-
-        protected override void Subtract(Span<uint> left, ReadOnlySpan<uint> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (uint)(left[i] - right[i]);
-        }
-
-        protected override void Subtract(Span<uint> left, uint right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (uint)(left[i] - right);
-        }
-
-        protected override void Subtract(uint left, Span<uint> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (uint)(left - right[i]);
-        }
-
-        protected override void Multiply(Span<uint> left, ReadOnlySpan<uint> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (uint)(left[i] * right[i]);
-        }
-
-        protected override void Multiply(Span<uint> left, uint right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (uint)(left[i] * right);
-        }
-
-        protected override void Multiply(uint left, Span<uint> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (uint)(left * right[i]);
-        }
-
-        protected override void Divide(Span<uint> left, Span<byte> leftValidity, ReadOnlySpan<uint> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    left[i] = (uint)(left[i] / right[i]);
-                else
-                    BitUtility.ClearBit(leftValidity, i);
-            }
-        }
-
-        protected override void Divide(Span<uint> left, uint right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (uint)(left[i] / right);
-        }
-
-        protected override void Divide(uint left, Span<uint> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < right.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    right[i] = (uint)(left / right[i]);
-            }
-        }
-
-        protected override void Modulo(Span<uint> left, ReadOnlySpan<uint> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (uint)(left[i] % right[i]);
-        }
-
-        protected override void Modulo(Span<uint> left, uint right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (uint)(left[i] % right);
-        }
-
-        protected override void Modulo(uint left, Span<uint> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (uint)(left % right[i]);
-        }
-
-        protected override void And(Span<uint> left, ReadOnlySpan<uint> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (uint)(left[i] & right[i]);
-        }
-
-        protected override void And(Span<uint> left, uint right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (uint)(left[i] & right);
-        }
-
-        protected override void And(uint left, Span<uint> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (uint)(left & right[i]);
-        }
-
-        protected override void Or(Span<uint> left, ReadOnlySpan<uint> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (uint)(left[i] | right[i]);
-        }
-
-        protected override void Or(Span<uint> left, uint right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (uint)(left[i] | right);
-        }
-
-        protected override void Or(uint left, Span<uint> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (uint)(left | right[i]);
-        }
-
-        protected override void Xor(Span<uint> left, ReadOnlySpan<uint> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (uint)(left[i] ^ right[i]);
-        }
-
-        protected override void Xor(Span<uint> left, uint right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (uint)(left[i] ^ right);
-        }
-
-        protected override void Xor(uint left, Span<uint> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (uint)(left ^ right[i]);
-        }
-
-        protected override void LeftShift(Span<uint> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (uint)(left[i] << right);
-        }
-
-        protected override void RightShift(Span<uint> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (uint)(left[i] >> right);
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<uint> left, ReadOnlySpan<uint> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right[i]);
-            }
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<uint> left, uint right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<uint> left, ReadOnlySpan<uint> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right[i]);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<uint> left, uint right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<uint> left, ReadOnlySpan<uint> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<uint> left, uint right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<uint> left, ReadOnlySpan<uint> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<uint> left, uint right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<uint> left, ReadOnlySpan<uint> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<uint> left, uint right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<uint> left, ReadOnlySpan<uint> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<uint> left, uint right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right);
-            }
-        }
-    }
-    internal class ULongArithmetic : PrimitiveDataFrameColumnArithmetic<ulong>
-    {
-
-        protected override void Add(Span<ulong> left, ReadOnlySpan<ulong> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ulong)(left[i] + right[i]);
-        }
-
-        protected override void Add(Span<ulong> left, ulong right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ulong)(left[i] + right);
-        }
-
-        protected override void Add(ulong left, Span<ulong> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (ulong)(left + right[i]);
-        }
-
-        protected override void Subtract(Span<ulong> left, ReadOnlySpan<ulong> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ulong)(left[i] - right[i]);
-        }
-
-        protected override void Subtract(Span<ulong> left, ulong right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ulong)(left[i] - right);
-        }
-
-        protected override void Subtract(ulong left, Span<ulong> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (ulong)(left - right[i]);
-        }
-
-        protected override void Multiply(Span<ulong> left, ReadOnlySpan<ulong> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ulong)(left[i] * right[i]);
-        }
-
-        protected override void Multiply(Span<ulong> left, ulong right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ulong)(left[i] * right);
-        }
-
-        protected override void Multiply(ulong left, Span<ulong> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (ulong)(left * right[i]);
-        }
-
-        protected override void Divide(Span<ulong> left, Span<byte> leftValidity, ReadOnlySpan<ulong> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    left[i] = (ulong)(left[i] / right[i]);
-                else
-                    BitUtility.ClearBit(leftValidity, i);
-            }
-        }
-
-        protected override void Divide(Span<ulong> left, ulong right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ulong)(left[i] / right);
-        }
-
-        protected override void Divide(ulong left, Span<ulong> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < right.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    right[i] = (ulong)(left / right[i]);
-            }
-        }
-
-        protected override void Modulo(Span<ulong> left, ReadOnlySpan<ulong> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ulong)(left[i] % right[i]);
-        }
-
-        protected override void Modulo(Span<ulong> left, ulong right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ulong)(left[i] % right);
-        }
-
-        protected override void Modulo(ulong left, Span<ulong> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (ulong)(left % right[i]);
-        }
-
-        protected override void And(Span<ulong> left, ReadOnlySpan<ulong> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ulong)(left[i] & right[i]);
-        }
-
-        protected override void And(Span<ulong> left, ulong right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ulong)(left[i] & right);
-        }
-
-        protected override void And(ulong left, Span<ulong> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (ulong)(left & right[i]);
-        }
-
-        protected override void Or(Span<ulong> left, ReadOnlySpan<ulong> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ulong)(left[i] | right[i]);
-        }
-
-        protected override void Or(Span<ulong> left, ulong right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ulong)(left[i] | right);
-        }
-
-        protected override void Or(ulong left, Span<ulong> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (ulong)(left | right[i]);
-        }
-
-        protected override void Xor(Span<ulong> left, ReadOnlySpan<ulong> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ulong)(left[i] ^ right[i]);
-        }
-
-        protected override void Xor(Span<ulong> left, ulong right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ulong)(left[i] ^ right);
-        }
-
-        protected override void Xor(ulong left, Span<ulong> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (ulong)(left ^ right[i]);
-        }
-
-        protected override void LeftShift(Span<ulong> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ulong)(left[i] << right);
-        }
-
-        protected override void RightShift(Span<ulong> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ulong)(left[i] >> right);
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<ulong> left, ReadOnlySpan<ulong> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right[i]);
-            }
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<ulong> left, ulong right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<ulong> left, ReadOnlySpan<ulong> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right[i]);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<ulong> left, ulong right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<ulong> left, ReadOnlySpan<ulong> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<ulong> left, ulong right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<ulong> left, ReadOnlySpan<ulong> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<ulong> left, ulong right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<ulong> left, ReadOnlySpan<ulong> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<ulong> left, ulong right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<ulong> left, ReadOnlySpan<ulong> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<ulong> left, ulong right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right);
-            }
-        }
-    }
-    internal class UShortArithmetic : PrimitiveDataFrameColumnArithmetic<ushort>
-    {
-
-        protected override void Add(Span<ushort> left, ReadOnlySpan<ushort> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ushort)(left[i] + right[i]);
-        }
-
-        protected override void Add(Span<ushort> left, ushort right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ushort)(left[i] + right);
-        }
-
-        protected override void Add(ushort left, Span<ushort> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (ushort)(left + right[i]);
-        }
-
-        protected override void Subtract(Span<ushort> left, ReadOnlySpan<ushort> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ushort)(left[i] - right[i]);
-        }
-
-        protected override void Subtract(Span<ushort> left, ushort right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ushort)(left[i] - right);
-        }
-
-        protected override void Subtract(ushort left, Span<ushort> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (ushort)(left - right[i]);
-        }
-
-        protected override void Multiply(Span<ushort> left, ReadOnlySpan<ushort> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ushort)(left[i] * right[i]);
-        }
-
-        protected override void Multiply(Span<ushort> left, ushort right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ushort)(left[i] * right);
-        }
-
-        protected override void Multiply(ushort left, Span<ushort> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (ushort)(left * right[i]);
-        }
-
-        protected override void Divide(Span<ushort> left, Span<byte> leftValidity, ReadOnlySpan<ushort> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    left[i] = (ushort)(left[i] / right[i]);
-                else
-                    BitUtility.ClearBit(leftValidity, i);
-            }
-        }
-
-        protected override void Divide(Span<ushort> left, ushort right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ushort)(left[i] / right);
-        }
-
-        protected override void Divide(ushort left, Span<ushort> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < right.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    right[i] = (ushort)(left / right[i]);
-            }
-        }
-
-        protected override void Modulo(Span<ushort> left, ReadOnlySpan<ushort> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ushort)(left[i] % right[i]);
-        }
-
-        protected override void Modulo(Span<ushort> left, ushort right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ushort)(left[i] % right);
-        }
-
-        protected override void Modulo(ushort left, Span<ushort> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (ushort)(left % right[i]);
-        }
-
-        protected override void And(Span<ushort> left, ReadOnlySpan<ushort> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ushort)(left[i] & right[i]);
-        }
-
-        protected override void And(Span<ushort> left, ushort right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ushort)(left[i] & right);
-        }
-
-        protected override void And(ushort left, Span<ushort> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (ushort)(left & right[i]);
-        }
-
-        protected override void Or(Span<ushort> left, ReadOnlySpan<ushort> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ushort)(left[i] | right[i]);
-        }
-
-        protected override void Or(Span<ushort> left, ushort right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ushort)(left[i] | right);
-        }
-
-        protected override void Or(ushort left, Span<ushort> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (ushort)(left | right[i]);
-        }
-
-        protected override void Xor(Span<ushort> left, ReadOnlySpan<ushort> right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ushort)(left[i] ^ right[i]);
-        }
-
-        protected override void Xor(Span<ushort> left, ushort right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ushort)(left[i] ^ right);
-        }
-
-        protected override void Xor(ushort left, Span<ushort> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (ushort)(left ^ right[i]);
-        }
-
-        protected override void LeftShift(Span<ushort> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ushort)(left[i] << right);
-        }
-
-        protected override void RightShift(Span<ushort> left, int right)
-        {
-            for (var i = 0; i < left.Length; i++)
-                left[i] = (ushort)(left[i] >> right);
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<ushort> left, ReadOnlySpan<ushort> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right[i]);
-            }
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<ushort> left, ushort right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<ushort> left, ReadOnlySpan<ushort> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right[i]);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<ushort> left, ushort right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<ushort> left, ReadOnlySpan<ushort> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThanOrEqual(ReadOnlySpan<ushort> left, ushort right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] >= right);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<ushort> left, ReadOnlySpan<ushort> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThanOrEqual(ReadOnlySpan<ushort> left, ushort right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] <= right);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<ushort> left, ReadOnlySpan<ushort> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right[i]);
-            }
-        }
-
-        protected override void ElementwiseGreaterThan(ReadOnlySpan<ushort> left, ushort right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] > right);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<ushort> left, ReadOnlySpan<ushort> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right[i]);
-            }
-        }
-
-        protected override void ElementwiseLessThan(ReadOnlySpan<ushort> left, ushort right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] < right);
-            }
-        }
-    }
-    internal class DateTimeArithmetic : PrimitiveDataFrameColumnArithmetic<DateTime>
-    {
-
-        protected override void ElementwiseEquals(ReadOnlySpan<DateTime> left, ReadOnlySpan<DateTime> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right[i]);
-            }
-        }
-
-        protected override void ElementwiseEquals(ReadOnlySpan<DateTime> left, DateTime right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] == right);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<DateTime> left, ReadOnlySpan<DateTime> right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right[i]);
-            }
-        }
-
-        protected override void ElementwiseNotEquals(ReadOnlySpan<DateTime> left, DateTime right, PrimitiveColumnContainer<bool> result, long offset)
-        {
-            for (var i = 0; i < left.Length; i++)
-            {
-                result[i + offset] = (left[i] != right);
-            }
-        }
-    }
-}
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt
deleted file mode 100644
index ec1478b66b..0000000000
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt
+++ /dev/null
@@ -1,240 +0,0 @@
-<#@ template debug="false" hostspecific="false" language="C#" #>
-<#@ assembly name="System" #>
-<#@ assembly name="System.Core" #>
-<#@ import namespace="System.Linq" #>
-<#@ import namespace="System.Text" #>
-<#@ import namespace="System.Collections.Generic" #>
-<#@ output extension=".cs" #>
-<#@ include file="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 PrimitiveDataFrameColumnArithmetic.tt. Do not modify directly
-
-using System;
-
-namespace Microsoft.Data.Analysis
-{
-    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.Binary) { #>
-<# if (method.MethodName != "Divide") { #>
-            else if (operation == BinaryOperation.<#=method.MethodName#>)
-                <#=method.MethodName#>(left, right);
-<# } #>
-<# } #>
-<# } #>
-
-            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;
-<# } #>
-<# } #>
-            }
-        }
-
-        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);
-<# } #>
-<# } #>
-<# } #>
-        }
-
-        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) { #>
-        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) { #>
-        protected virtual void <#=method.MethodName#>(ReadOnlySpan<T> left, T right, PrimitiveColumnContainer<bool> result, long offset) => throw new NotSupportedException();
-<# } #>
-<# else if (method.MethodType == MethodType.Binary) { #>
-<# 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) { #>
-        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) { #>
-        protected virtual void <#=method.MethodName#>(Span<T> left, int right) => throw new NotSupportedException();
-<# } #>
-<# } #>
-
-    }
-
-    internal static class PrimitiveDataFrameColumnArithmetic
-    {
-        public static IPrimitiveDataFrameColumnArithmetic<T> GetArithmetic<T>()
-            where T : unmanaged
-        {
-<# 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#>>
-    {
-<# foreach (MethodConfiguration method in methodConfiguration) { #>
-<# if (!((method.IsNumeric && !type.SupportsNumeric) || (method.IsBitwise && !type.SupportsBitwise) || (type.UnsupportedMethods.Contains(method.MethodName))) && method.Operator != null) { #>
-<# if (method.MethodType == MethodType.Comparison) { #>
-
-        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) {#>
-
-        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") { #>
-
-        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) { #>
-
-        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") { #>
-
-        protected override void <#=method.MethodName#>(<#=type.TypeName#> left, Span<<#=type.TypeName#>> right, ReadOnlySpan<byte> rightValidity)
-        {
-            for (var i = 0; i < right.Length; i++)
-            {
-                if (BitUtility.IsValid(rightValidity, i))
-                    right[i] = (<#=type.TypeName#>)(left <#= method.Operator #> right[i]);
-            }
-        }
-<# } #>
-<# else { #>
-
-        protected override void <#=method.MethodName#>(<#=type.TypeName#> left, Span<<#=type.TypeName#>> right)
-        {
-            for (var i = 0; i < right.Length; i++)
-                right[i] = (<#=type.TypeName#>)(left <#= method.Operator #> right[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/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs b/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs
index 69d868eee8..d5540edf23 100644
--- a/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs
+++ b/test/Microsoft.Data.Analysis.Tests/DataFrameTests.cs
@@ -3696,11 +3696,12 @@ public void Test_StringColumnEqualsNull()
         }
 
         [Fact]
-        public void Test_ArithmeticsSumWithNull()
+        public void Test_ArithmeticsAddWithNull()
         {
             // Arrange
-            var left_column = new Int32DataFrameColumn("Left", new int?[] { 1, 1, null, null });
-            var right_column = new Int32DataFrameColumn("Right", new int?[] { 1, null, 1, null });
+            //Number of elements shoult be higher than 8 to test SIMD
+            var left_column = new Int32DataFrameColumn("Left", new int?[] { 1, 1, null, null, 4, 5, 6, 7, 8, 9 });
+            var right_column = new Int32DataFrameColumn("Right", new int?[] { 1, null, 1, null, 4, 5, 6, 7, 8, 9 });
 
             // Act
             var sum = left_column + right_column;
@@ -3712,6 +3713,37 @@ public void Test_ArithmeticsSumWithNull()
             Assert.Null(sum[1]); // null + 1
             Assert.Null(sum[2]); // 1 + null
             Assert.Null(sum[3]); // null + null
+            Assert.Equal(8, sum[4]);
+            Assert.Equal(10, sum[5]);
+            Assert.Equal(12, sum[6]);
+            Assert.Equal(14, sum[7]);
+            Assert.Equal(16, sum[8]);
+            Assert.Equal(18, sum[9]);
+        }
+
+        [Fact]
+        public void Test_ArithmeticsAddScalarWithNull()
+        {
+            // Arrange
+            //Number of elements shoult be higher than 8 to test SIMD
+            var left_column = new Int32DataFrameColumn("Left", new int?[] { 0, 1, null, null, 4, 5, 6, 7, 8, null });
+
+            // Act
+            var sum = left_column + 5;
+
+            // Assert
+            Assert.Equal(3, sum.NullCount);
+
+            Assert.Equal(5, sum[0]);  // 1 + 1
+            Assert.Equal(6, sum[1]);  // 1 + 1
+            Assert.Null(sum[2]); // 1 + null
+            Assert.Null(sum[3]); // null + null
+            Assert.Equal(9, sum[4]);
+            Assert.Equal(10, sum[5]);
+            Assert.Equal(11, sum[6]);
+            Assert.Equal(12, sum[7]);
+            Assert.Equal(13, sum[8]);
+            Assert.Null(sum[9]);
         }
 
         [Fact]