From 9796936ed67136aa919b10b6c1be9ecac0bbb300 Mon Sep 17 00:00:00 2001
From: Aleksei Smirnov <tlalok@inbox.ru>
Date: Thu, 13 Jul 2023 14:31:19 +0300
Subject: [PATCH 1/6] Change methods signature generation

---
 .../ColumnArithmeticTemplate.ttinclude        |  16 +-
 .../DataFrameColumn.BinaryOperations.tt       |   6 +
 ...imitiveColumnContainer.BinaryOperations.cs |  74 ++--
 ...imitiveColumnContainer.BinaryOperations.tt |  21 +-
 ...rimitiveDataFrameColumn.BinaryOperators.cs |   2 +
 ...rimitiveDataFrameColumn.BinaryOperators.tt |   2 +
 .../PrimitiveDataFrameColumnArithmetic.cs     | 360 +++++++++---------
 .../PrimitiveDataFrameColumnArithmetic.tt     |   4 +-
 8 files changed, 232 insertions(+), 253 deletions(-)

diff --git a/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude b/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude
index bb31da6a94..c9a89655fd 100644
--- a/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude
+++ b/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude
@@ -354,13 +354,7 @@
         {
             return GetColumnSpecificMethodComments().Replace(" an", " a reversed");
         }
-
-        public string GetMethodSignature(string columnType, string genericType)
-        {
-            var arguments = GetMethodArguments(columnType, genericType);
-            return $"void {MethodName}({arguments})";
-        }
-
+                
         public string GetInvertedMethodSignatureForBinaryScalarsOps(string columnType, string genericType)
         {
             var arguments = GetInvertedMethodArguments(columnType, genericType);
@@ -408,13 +402,13 @@
                 case MethodType.BinaryScalar:
                     return $"{dataFrameType}<{genericType}> {Op1Name}, {genericType} {Op2Name}";
                 case MethodType.ComparisonScalar:
-                    return $"{dataFrameType}<{genericType}> {Op1Name}, {genericType} {Op2Name}, {dataFrameType}<bool> ret";
+                    return $"{dataFrameType}<{genericType}> {Op1Name}, {genericType} {Op2Name}";
                 case MethodType.BinaryInt:
                     return $"{dataFrameType}<{genericType}> {Op1Name}, int {Op2Name}";
                 case MethodType.Binary:
                     return $"{dataFrameType}<{genericType}> {Op1Name}, {dataFrameType}<{genericType}> {Op2Name}";
                 case MethodType.Comparison:
-                    return $"{dataFrameType}<{genericType}> {Op1Name}, {dataFrameType}<{genericType}> {Op2Name}, {dataFrameType}<bool> ret";
+                    return $"{dataFrameType}<{genericType}> {Op1Name}, {dataFrameType}<{genericType}> {Op2Name}";
                 case MethodType.Contraction:
                     return $"{dataFrameType}<{genericType}> {Op1Name}, {dataFrameType}<{genericType}> {Op2Name}, int[] leftAxes, int[] rightAxes";
                 case MethodType.ElementwiseComputation:
@@ -436,13 +430,13 @@
                 case MethodType.BinaryScalar:
                     return $"{genericType} {Op2Name}";
                 case MethodType.ComparisonScalar:
-                    return $"{genericType} {Op2Name}, {dataFrameType}<bool> ret";
+                    return $"{genericType} {Op2Name}";
                 case MethodType.BinaryInt:
                     return $"int {Op2Name}";
                 case MethodType.Binary:
                     return $"{dataFrameType}<{genericType}> {Op2Name}";
                 case MethodType.Comparison:
-                    return $"{dataFrameType}<{genericType}> {Op2Name}, {dataFrameType}<bool> ret";
+                    return $"{dataFrameType}<{genericType}> {Op2Name}";
                 case MethodType.Contraction:
                     throw new ArgumentException();
                     return $"{dataFrameType}<{genericType}> {Op1Name}, {dataFrameType}<{genericType}> {Op2Name}, int[] leftAxes, int[] rightAxes";
diff --git a/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt b/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt
index a417bbf876..dc0c4fa988 100644
--- a/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt
+++ b/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt
@@ -78,11 +78,17 @@ namespace Microsoft.Data.Analysis
 
 <# } #>
 <# } #>
+        /// <summary>
+        /// Performs an element-wise equal to Null on each value in the column
+        /// </summary>
         public virtual PrimitiveDataFrameColumn<bool> ElementwiseIsNull()
         {
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Performs an element-wise not equal to Null on each value in the column
+        /// </summary>
         public virtual PrimitiveDataFrameColumn<bool> ElementwiseIsNotNull()
         {
             throw new NotImplementedException();
diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs
index 64b12c0607..e6c6673152 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs
@@ -118,78 +118,54 @@ public PrimitiveColumnContainer<T> RightShift(int value)
             return this;
         }
 
-        public PrimitiveColumnContainer<T> ElementwiseEquals(PrimitiveColumnContainer<T> right, PrimitiveColumnContainer<bool> ret)
+        public BooleanDataFrameColumn ElementwiseEquals(PrimitiveColumnContainer<T> right)
         {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseEquals(this, right, ret);
-            return this;
+            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseEquals(this, right);
         }
-
-        public PrimitiveColumnContainer<T> ElementwiseEquals(T scalar, PrimitiveColumnContainer<bool> ret)
+        public BooleanDataFrameColumn ElementwiseEquals(T scalar)
         {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseEquals(this, scalar, ret);
-            return this;
+            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseEquals(this, scalar);
         }
-
-        public PrimitiveColumnContainer<T> ElementwiseNotEquals(PrimitiveColumnContainer<T> right, PrimitiveColumnContainer<bool> ret)
+        public BooleanDataFrameColumn ElementwiseNotEquals(PrimitiveColumnContainer<T> right)
         {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseNotEquals(this, right, ret);
-            return this;
+            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseNotEquals(this, right);
         }
-
-        public PrimitiveColumnContainer<T> ElementwiseNotEquals(T scalar, PrimitiveColumnContainer<bool> ret)
+        public BooleanDataFrameColumn ElementwiseNotEquals(T scalar)
         {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseNotEquals(this, scalar, ret);
-            return this;
+            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseNotEquals(this, scalar);
         }
-
-        public PrimitiveColumnContainer<T> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<T> right, PrimitiveColumnContainer<bool> ret)
+        public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<T> right)
         {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThanOrEqual(this, right, ret);
-            return this;
+            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThanOrEqual(this, right);
         }
-
-        public PrimitiveColumnContainer<T> ElementwiseGreaterThanOrEqual(T scalar, PrimitiveColumnContainer<bool> ret)
+        public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(T scalar)
         {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThanOrEqual(this, scalar, ret);
-            return this;
+            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThanOrEqual(this, scalar);
         }
-
-        public PrimitiveColumnContainer<T> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<T> right, PrimitiveColumnContainer<bool> ret)
+        public BooleanDataFrameColumn ElementwiseLessThanOrEqual(PrimitiveColumnContainer<T> right)
         {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThanOrEqual(this, right, ret);
-            return this;
+            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThanOrEqual(this, right);
         }
-
-        public PrimitiveColumnContainer<T> ElementwiseLessThanOrEqual(T scalar, PrimitiveColumnContainer<bool> ret)
+        public BooleanDataFrameColumn ElementwiseLessThanOrEqual(T scalar)
         {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThanOrEqual(this, scalar, ret);
-            return this;
+            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThanOrEqual(this, scalar);
         }
-
-        public PrimitiveColumnContainer<T> ElementwiseGreaterThan(PrimitiveColumnContainer<T> right, PrimitiveColumnContainer<bool> ret)
+        public BooleanDataFrameColumn ElementwiseGreaterThan(PrimitiveColumnContainer<T> right)
         {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThan(this, right, ret);
-            return this;
+            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThan(this, right);
         }
-
-        public PrimitiveColumnContainer<T> ElementwiseGreaterThan(T scalar, PrimitiveColumnContainer<bool> ret)
+        public BooleanDataFrameColumn ElementwiseGreaterThan(T scalar)
         {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThan(this, scalar, ret);
-            return this;
+            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThan(this, scalar);
         }
-
-        public PrimitiveColumnContainer<T> ElementwiseLessThan(PrimitiveColumnContainer<T> right, PrimitiveColumnContainer<bool> ret)
+        public BooleanDataFrameColumn ElementwiseLessThan(PrimitiveColumnContainer<T> right)
         {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThan(this, right, ret);
-            return this;
+            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThan(this, right);
         }
-
-        public PrimitiveColumnContainer<T> ElementwiseLessThan(T scalar, PrimitiveColumnContainer<bool> ret)
+        public BooleanDataFrameColumn ElementwiseLessThan(T scalar)
         {
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThan(this, scalar, ret);
-            return this;
+            return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThan(this, scalar);
         }
-
         public PrimitiveColumnContainer<T> ReverseAdd(T scalar)
         {
             PrimitiveDataFrameColumnArithmetic<T>.Instance.Add(scalar, this);
@@ -231,4 +207,4 @@ public PrimitiveColumnContainer<T> ReverseXor(T scalar)
             return this;
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt
index 95fc73b176..c6ce66a40b 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt
+++ b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt
@@ -14,20 +14,19 @@
 namespace Microsoft.Data.Analysis
 {
     internal partial class PrimitiveColumnContainer<T>
-        where T : struct
+        where T : unmanaged
     {
 <# foreach (MethodConfiguration method in methodConfiguration) { #>
-<# if (method.MethodType == MethodType.Comparison || method.MethodType == MethodType.ComparisonScalar) { #>
-        public <#= method.GetSingleArgumentMethodSignature("PrimitiveColumnContainer", "T") #>
+<# if (method.MethodType == MethodType.Comparison) { #>
+        public BooleanDataFrameColumn <#=method.MethodName#>(PrimitiveColumnContainer<T> right)
         {
-<# if (method.MethodType == MethodType.ComparisonScalar ) { #>
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.<#=method.MethodName#>(this, scalar, ret);
-<# } else { #>
-            PrimitiveDataFrameColumnArithmetic<T>.Instance.<#=method.MethodName#>(this, right, ret);
-<# } #>
-            return this;
+            return PrimitiveDataFrameColumnArithmetic<T>.Instance.<#=method.MethodName#>(this, right);
+        }
+<# } else if (method.MethodType == MethodType.ComparisonScalar ) { #>
+        public BooleanDataFrameColumn <#=method.MethodName#>(T scalar)
+        {
+            return PrimitiveDataFrameColumnArithmetic<T>.Instance.<#=method.MethodName#>(this, scalar);
         }
-
 <# } else { #>
         public <#= method.GetSingleArgumentMethodSignature("PrimitiveColumnContainer", "T")#>
         {
@@ -53,4 +52,4 @@ namespace Microsoft.Data.Analysis
 <# } #>
 <# } #>
     }
-}
+}
\ No newline at end of file
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperators.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperators.cs
index ab89c880d9..fdacb805b1 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperators.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperators.cs
@@ -4,6 +4,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// Generated from PrimitiveDataFrameColumn.BinaryOperators.tt. Do not modify directly
+
 using System;
 using System.Collections.Generic;
 using System.Text;
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperators.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperators.tt
index 777dc4026d..88063aae44 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperators.tt
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperators.tt
@@ -10,6 +10,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// Generated from PrimitiveDataFrameColumn.BinaryOperators.tt. Do not modify directly
+
 using System;
 using System.Collections.Generic;
 using System.Text;
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs
index 0c8a0ec2ff..d7dfd7fd67 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs
@@ -39,18 +39,18 @@ internal interface IPrimitiveDataFrameColumnArithmetic<T>
         void Xor(T scalar, PrimitiveColumnContainer<T> column);
         void LeftShift(PrimitiveColumnContainer<T> column, int value);
         void RightShift(PrimitiveColumnContainer<T> column, int value);
-        void ElementwiseEquals(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right, PrimitiveColumnContainer<bool> ret);
-        void ElementwiseEquals(PrimitiveColumnContainer<T> column, T scalar, PrimitiveColumnContainer<bool> ret);
-        void ElementwiseNotEquals(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right, PrimitiveColumnContainer<bool> ret);
-        void ElementwiseNotEquals(PrimitiveColumnContainer<T> column, T scalar, PrimitiveColumnContainer<bool> ret);
-        void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right, PrimitiveColumnContainer<bool> ret);
-        void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<T> column, T scalar, PrimitiveColumnContainer<bool> ret);
-        void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right, PrimitiveColumnContainer<bool> ret);
-        void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<T> column, T scalar, PrimitiveColumnContainer<bool> ret);
-        void ElementwiseGreaterThan(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right, PrimitiveColumnContainer<bool> ret);
-        void ElementwiseGreaterThan(PrimitiveColumnContainer<T> column, T scalar, PrimitiveColumnContainer<bool> ret);
-        void ElementwiseLessThan(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right, PrimitiveColumnContainer<bool> ret);
-        void ElementwiseLessThan(PrimitiveColumnContainer<T> column, T scalar, PrimitiveColumnContainer<bool> ret);
+        void ElementwiseEquals(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
+        void ElementwiseEquals(PrimitiveColumnContainer<T> column, T scalar);
+        void ElementwiseNotEquals(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
+        void ElementwiseNotEquals(PrimitiveColumnContainer<T> column, T scalar);
+        void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
+        void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<T> column, T scalar);
+        void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
+        void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<T> column, T scalar);
+        void ElementwiseGreaterThan(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
+        void ElementwiseGreaterThan(PrimitiveColumnContainer<T> column, T scalar);
+        void ElementwiseLessThan(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
+        void ElementwiseLessThan(PrimitiveColumnContainer<T> column, T scalar);
     }
 
     internal static class PrimitiveDataFrameColumnArithmetic<T>
@@ -305,7 +305,7 @@ public void RightShift(PrimitiveColumnContainer<bool> column, int value)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -318,7 +318,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<bool> left, PrimitiveColu
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<bool> column, bool scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<bool> column, bool scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -330,7 +330,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<bool> column, bool scalar
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -343,7 +343,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<bool> left, PrimitiveC
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<bool> column, bool scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<bool> column, bool scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -355,35 +355,35 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<bool> column, bool sca
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<bool> column, bool scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<bool> column, bool scalar)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<bool> column, bool scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<bool> column, bool scalar)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<bool> column, bool scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<bool> column, bool scalar)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<bool> column, bool scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<bool> column, bool scalar)
         {
             throw new NotSupportedException();
         }
@@ -710,7 +710,7 @@ public void RightShift(PrimitiveColumnContainer<byte> column, int value)
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -723,7 +723,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<byte> left, PrimitiveColu
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<byte> column, byte scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<byte> column, byte scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -735,7 +735,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<byte> column, byte scalar
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -748,7 +748,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<byte> left, PrimitiveC
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<byte> column, byte scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<byte> column, byte scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -760,7 +760,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<byte> column, byte sca
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -773,7 +773,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<byte> left, P
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<byte> column, byte scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<byte> column, byte scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -785,7 +785,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<byte> column,
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -798,7 +798,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<byte> left, Prim
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<byte> column, byte scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<byte> column, byte scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -810,7 +810,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<byte> column, by
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -823,7 +823,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<byte> left, Primitiv
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<byte> column, byte scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<byte> column, byte scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -835,7 +835,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<byte> column, byte s
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -848,7 +848,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<byte> left, PrimitiveCo
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<byte> column, byte scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<byte> column, byte scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1183,7 +1183,7 @@ public void RightShift(PrimitiveColumnContainer<char> column, int value)
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1196,7 +1196,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<char> left, PrimitiveColu
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<char> column, char scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<char> column, char scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1208,7 +1208,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<char> column, char scalar
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1221,7 +1221,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<char> left, PrimitiveC
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<char> column, char scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<char> column, char scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1233,7 +1233,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<char> column, char sca
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1246,7 +1246,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<char> left, P
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<char> column, char scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<char> column, char scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1258,7 +1258,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<char> column,
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1271,7 +1271,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<char> left, Prim
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<char> column, char scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<char> column, char scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1283,7 +1283,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<char> column, ch
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1296,7 +1296,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<char> left, Primitiv
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<char> column, char scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<char> column, char scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1308,7 +1308,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<char> column, char s
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1321,7 +1321,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<char> left, PrimitiveCo
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<char> column, char scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<char> column, char scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1565,7 +1565,7 @@ public void RightShift(PrimitiveColumnContainer<decimal> column, int value)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1578,7 +1578,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<decimal> left, PrimitiveC
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<decimal> column, decimal scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1590,7 +1590,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<decimal> column, decimal
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1603,7 +1603,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<decimal> left, Primiti
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<decimal> column, decimal scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1615,7 +1615,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<decimal> column, decim
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1628,7 +1628,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<decimal> left
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<decimal> column, decimal scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1640,7 +1640,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<decimal> colu
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1653,7 +1653,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<decimal> left, P
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<decimal> column, decimal scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1665,7 +1665,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<decimal> column,
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1678,7 +1678,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<decimal> left, Primi
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<decimal> column, decimal scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1690,7 +1690,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<decimal> column, dec
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1703,7 +1703,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<decimal> left, Primitiv
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<decimal> column, decimal scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1947,7 +1947,7 @@ public void RightShift(PrimitiveColumnContainer<double> column, int value)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1960,7 +1960,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<double> left, PrimitiveCo
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<double> column, double scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<double> column, double scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1972,7 +1972,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<double> column, double sc
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1985,7 +1985,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<double> left, Primitiv
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<double> column, double scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<double> column, double scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1997,7 +1997,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<double> column, double
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2010,7 +2010,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<double> left,
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<double> column, double scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<double> column, double scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2022,7 +2022,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<double> colum
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2035,7 +2035,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<double> left, Pr
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<double> column, double scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<double> column, double scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2047,7 +2047,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<double> column,
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2060,7 +2060,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<double> left, Primit
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<double> column, double scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<double> column, double scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2072,7 +2072,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<double> column, doub
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2085,7 +2085,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<double> left, Primitive
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<double> column, double scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<double> column, double scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2329,7 +2329,7 @@ public void RightShift(PrimitiveColumnContainer<float> column, int value)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2342,7 +2342,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<float> left, PrimitiveCol
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<float> column, float scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<float> column, float scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2354,7 +2354,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<float> column, float scal
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2367,7 +2367,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<float> left, Primitive
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<float> column, float scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<float> column, float scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2379,7 +2379,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<float> column, float s
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2392,7 +2392,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<float> left,
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<float> column, float scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<float> column, float scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2404,7 +2404,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<float> column
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2417,7 +2417,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<float> left, Pri
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<float> column, float scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<float> column, float scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2429,7 +2429,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<float> column, f
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2442,7 +2442,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<float> left, Primiti
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<float> column, float scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<float> column, float scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2454,7 +2454,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<float> column, float
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2467,7 +2467,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<float> left, PrimitiveC
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<float> column, float scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<float> column, float scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2802,7 +2802,7 @@ public void RightShift(PrimitiveColumnContainer<int> column, int value)
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2815,7 +2815,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<int> left, PrimitiveColum
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<int> column, int scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<int> column, int scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2827,7 +2827,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<int> column, int scalar,
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2840,7 +2840,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<int> left, PrimitiveCo
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<int> column, int scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<int> column, int scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2852,7 +2852,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<int> column, int scala
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2865,7 +2865,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<int> left, Pr
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<int> column, int scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<int> column, int scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2877,7 +2877,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<int> column,
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2890,7 +2890,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<int> left, Primi
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<int> column, int scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<int> column, int scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2902,7 +2902,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<int> column, int
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2915,7 +2915,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<int> left, Primitive
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<int> column, int scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<int> column, int scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2927,7 +2927,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<int> column, int sca
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2940,7 +2940,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<int> left, PrimitiveCol
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<int> column, int scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<int> column, int scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3275,7 +3275,7 @@ public void RightShift(PrimitiveColumnContainer<long> column, int value)
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3288,7 +3288,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<long> left, PrimitiveColu
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<long> column, long scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<long> column, long scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3300,7 +3300,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<long> column, long scalar
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3313,7 +3313,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<long> left, PrimitiveC
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<long> column, long scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<long> column, long scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3325,7 +3325,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<long> column, long sca
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3338,7 +3338,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<long> left, P
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<long> column, long scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<long> column, long scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3350,7 +3350,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<long> column,
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3363,7 +3363,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<long> left, Prim
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<long> column, long scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<long> column, long scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3375,7 +3375,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<long> column, lo
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3388,7 +3388,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<long> left, Primitiv
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<long> column, long scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<long> column, long scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3400,7 +3400,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<long> column, long s
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3413,7 +3413,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<long> left, PrimitiveCo
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<long> column, long scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<long> column, long scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3748,7 +3748,7 @@ public void RightShift(PrimitiveColumnContainer<sbyte> column, int value)
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3761,7 +3761,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<sbyte> left, PrimitiveCol
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<sbyte> column, sbyte scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3773,7 +3773,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<sbyte> column, sbyte scal
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3786,7 +3786,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<sbyte> left, Primitive
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<sbyte> column, sbyte scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3798,7 +3798,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<sbyte> column, sbyte s
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3811,7 +3811,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<sbyte> left,
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<sbyte> column, sbyte scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3823,7 +3823,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<sbyte> column
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3836,7 +3836,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<sbyte> left, Pri
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<sbyte> column, sbyte scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3848,7 +3848,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<sbyte> column, s
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3861,7 +3861,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<sbyte> left, Primiti
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<sbyte> column, sbyte scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3873,7 +3873,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<sbyte> column, sbyte
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3886,7 +3886,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<sbyte> left, PrimitiveC
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<sbyte> column, sbyte scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4221,7 +4221,7 @@ public void RightShift(PrimitiveColumnContainer<short> column, int value)
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4234,7 +4234,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<short> left, PrimitiveCol
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<short> column, short scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<short> column, short scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4246,7 +4246,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<short> column, short scal
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4259,7 +4259,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<short> left, Primitive
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<short> column, short scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<short> column, short scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4271,7 +4271,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<short> column, short s
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4284,7 +4284,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<short> left,
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<short> column, short scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<short> column, short scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4296,7 +4296,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<short> column
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4309,7 +4309,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<short> left, Pri
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<short> column, short scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<short> column, short scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4321,7 +4321,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<short> column, s
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4334,7 +4334,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<short> left, Primiti
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<short> column, short scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<short> column, short scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4346,7 +4346,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<short> column, short
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4359,7 +4359,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<short> left, PrimitiveC
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<short> column, short scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<short> column, short scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4694,7 +4694,7 @@ public void RightShift(PrimitiveColumnContainer<uint> column, int value)
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4707,7 +4707,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<uint> left, PrimitiveColu
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<uint> column, uint scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<uint> column, uint scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4719,7 +4719,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<uint> column, uint scalar
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4732,7 +4732,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<uint> left, PrimitiveC
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<uint> column, uint scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<uint> column, uint scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4744,7 +4744,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<uint> column, uint sca
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4757,7 +4757,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<uint> left, P
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<uint> column, uint scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<uint> column, uint scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4769,7 +4769,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<uint> column,
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4782,7 +4782,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<uint> left, Prim
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<uint> column, uint scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<uint> column, uint scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4794,7 +4794,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<uint> column, ui
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4807,7 +4807,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<uint> left, Primitiv
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<uint> column, uint scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<uint> column, uint scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4819,7 +4819,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<uint> column, uint s
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4832,7 +4832,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<uint> left, PrimitiveCo
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<uint> column, uint scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<uint> column, uint scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5167,7 +5167,7 @@ public void RightShift(PrimitiveColumnContainer<ulong> column, int value)
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5180,7 +5180,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<ulong> left, PrimitiveCol
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<ulong> column, ulong scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5192,7 +5192,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<ulong> column, ulong scal
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5205,7 +5205,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<ulong> left, Primitive
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<ulong> column, ulong scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5217,7 +5217,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<ulong> column, ulong s
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5230,7 +5230,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ulong> left,
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ulong> column, ulong scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5242,7 +5242,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ulong> column
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5255,7 +5255,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ulong> left, Pri
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ulong> column, ulong scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5267,7 +5267,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ulong> column, u
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5280,7 +5280,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<ulong> left, Primiti
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<ulong> column, ulong scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5292,7 +5292,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<ulong> column, ulong
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5305,7 +5305,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<ulong> left, PrimitiveC
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<ulong> column, ulong scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5640,7 +5640,7 @@ public void RightShift(PrimitiveColumnContainer<ushort> column, int value)
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5653,7 +5653,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<ushort> left, PrimitiveCo
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<ushort> column, ushort scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5665,7 +5665,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<ushort> column, ushort sc
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5678,7 +5678,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<ushort> left, Primitiv
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<ushort> column, ushort scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5690,7 +5690,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<ushort> column, ushort
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5703,7 +5703,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ushort> left,
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ushort> column, ushort scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5715,7 +5715,7 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ushort> colum
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5728,7 +5728,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ushort> left, Pr
                 }
             }
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ushort> column, ushort scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5740,7 +5740,7 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ushort> column,
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5753,7 +5753,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<ushort> left, Primit
                 }
             }
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<ushort> column, ushort scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5765,7 +5765,7 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<ushort> column, usho
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5778,7 +5778,7 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<ushort> left, Primitive
                 }
             }
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<ushort> column, ushort scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5897,7 +5897,7 @@ public void RightShift(PrimitiveColumnContainer<DateTime> column, int value)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5910,7 +5910,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<DateTime> left, Primitive
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<DateTime> column, DateTime scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseEquals(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5922,7 +5922,7 @@ public void ElementwiseEquals(PrimitiveColumnContainer<DateTime> column, DateTim
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5935,7 +5935,7 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<DateTime> left, Primit
                 }
             }
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<DateTime> column, DateTime scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseNotEquals(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5947,35 +5947,35 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<DateTime> column, Date
                 }
             }
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<DateTime> column, DateTime scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<DateTime> column, DateTime scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<DateTime> column, DateTime scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseGreaterThan(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<DateTime> column, DateTime scalar, PrimitiveColumnContainer<bool> ret)
+        public void ElementwiseLessThan(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
             throw new NotSupportedException();
         }
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt
index a1543efd2d..790eb2bfca 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt
@@ -21,7 +21,7 @@ namespace Microsoft.Data.Analysis
         where T : unmanaged
     {
 <# foreach (MethodConfiguration method in methodConfiguration) { #>
-        <#= method.GetMethodSignature("PrimitiveColumnContainer", "T")#>;
+        void <#=method.MethodName#>(<#=method.GetMethodArguments("PrimitiveColumnContainer", "T")#>);
 <# if (method.MethodType == MethodType.BinaryScalar) { #>
         <#= method.GetInvertedMethodSignatureForBinaryScalarsOps("PrimitiveColumnContainer", "T")#>;
 <# } #>
@@ -53,7 +53,7 @@ namespace Microsoft.Data.Analysis
     internal class <#=type.ClassPrefix#>Arithmetic : IPrimitiveDataFrameColumnArithmetic<<#=type.TypeName#>>
     {
 <# foreach (MethodConfiguration method in methodConfiguration) { #>
-        public <#= method.GetMethodSignature("PrimitiveColumnContainer", type.TypeName) #>
+        public void <#=method.MethodName#>(<#=method.GetMethodArguments("PrimitiveColumnContainer", type.TypeName)#>)
         {
 <# if ((method.IsNumeric && !type.SupportsNumeric) || (method.IsBitwise && !type.SupportsBitwise) || (type.UnsupportedMethods.Contains(method.MethodName))) { #>
             throw new NotSupportedException();

From bf29980fdd0ec9fdd06ccb5a35df7c81629729bf Mon Sep 17 00:00:00 2001
From: Aleksei Smirnov <tlalok@inbox.ru>
Date: Thu, 13 Jul 2023 17:25:00 +0300
Subject: [PATCH 2/6] Change DataFrameColumn Arithmetics

---
 ...imitiveColumnContainer.BinaryOperations.cs |   24 +-
 ...imitiveColumnContainer.BinaryOperations.tt |    4 +-
 ...BinaryOperationImplementations.Exploded.cs |  850 ++++++------
 ...BinaryOperationImplementations.Exploded.tt |   11 +-
 .../PrimitiveDataFrameColumnArithmetic.cs     | 1197 ++++++++++++++---
 .../PrimitiveDataFrameColumnArithmetic.tt     |   17 +-
 6 files changed, 1433 insertions(+), 670 deletions(-)

diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs
index e6c6673152..a17c888f36 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs
@@ -118,51 +118,51 @@ public PrimitiveColumnContainer<T> RightShift(int value)
             return this;
         }
 
-        public BooleanDataFrameColumn ElementwiseEquals(PrimitiveColumnContainer<T> right)
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<T> right)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseEquals(this, right);
         }
-        public BooleanDataFrameColumn ElementwiseEquals(T scalar)
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(T scalar)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseEquals(this, scalar);
         }
-        public BooleanDataFrameColumn ElementwiseNotEquals(PrimitiveColumnContainer<T> right)
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<T> right)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseNotEquals(this, right);
         }
-        public BooleanDataFrameColumn ElementwiseNotEquals(T scalar)
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(T scalar)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseNotEquals(this, scalar);
         }
-        public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<T> right)
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<T> right)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThanOrEqual(this, right);
         }
-        public BooleanDataFrameColumn ElementwiseGreaterThanOrEqual(T scalar)
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(T scalar)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThanOrEqual(this, scalar);
         }
-        public BooleanDataFrameColumn ElementwiseLessThanOrEqual(PrimitiveColumnContainer<T> right)
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<T> right)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThanOrEqual(this, right);
         }
-        public BooleanDataFrameColumn ElementwiseLessThanOrEqual(T scalar)
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(T scalar)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThanOrEqual(this, scalar);
         }
-        public BooleanDataFrameColumn ElementwiseGreaterThan(PrimitiveColumnContainer<T> right)
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<T> right)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThan(this, right);
         }
-        public BooleanDataFrameColumn ElementwiseGreaterThan(T scalar)
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(T scalar)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThan(this, scalar);
         }
-        public BooleanDataFrameColumn ElementwiseLessThan(PrimitiveColumnContainer<T> right)
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<T> right)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThan(this, right);
         }
-        public BooleanDataFrameColumn ElementwiseLessThan(T scalar)
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(T scalar)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThan(this, scalar);
         }
diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt
index c6ce66a40b..9bdd5c9c85 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt
+++ b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt
@@ -18,12 +18,12 @@ namespace Microsoft.Data.Analysis
     {
 <# foreach (MethodConfiguration method in methodConfiguration) { #>
 <# if (method.MethodType == MethodType.Comparison) { #>
-        public BooleanDataFrameColumn <#=method.MethodName#>(PrimitiveColumnContainer<T> right)
+        public PrimitiveColumnContainer<bool> <#=method.MethodName#>(PrimitiveColumnContainer<T> right)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.<#=method.MethodName#>(this, right);
         }
 <# } else if (method.MethodType == MethodType.ComparisonScalar ) { #>
-        public BooleanDataFrameColumn <#=method.MethodName#>(T scalar)
+        public PrimitiveColumnContainer<bool> <#=method.MethodName#>(T scalar)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.<#=method.MethodName#>(this, scalar);
         }
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs
index af3ac7e5ee..95e443545e 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs
@@ -102,6 +102,7 @@ internal UInt64DataFrameColumn AddImplementation(UInt64DataFrameColumn column, b
             return newColumn;
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal DecimalDataFrameColumn AddImplementation(decimal value, bool inPlace = false)
@@ -111,6 +112,7 @@ internal DecimalDataFrameColumn AddImplementation(decimal value, bool inPlace =
             return newColumn;
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal DoubleDataFrameColumn AddImplementation(double value, bool inPlace = false)
@@ -120,6 +122,7 @@ internal DoubleDataFrameColumn AddImplementation(double value, bool inPlace = fa
             return newColumn;
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal SingleDataFrameColumn AddImplementation(float value, bool inPlace = false)
@@ -129,6 +132,7 @@ internal SingleDataFrameColumn AddImplementation(float value, bool inPlace = fal
             return newColumn;
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal Int32DataFrameColumn AddImplementation(int value, bool inPlace = false)
@@ -138,6 +142,7 @@ internal Int32DataFrameColumn AddImplementation(int value, bool inPlace = false)
             return newColumn;
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal Int64DataFrameColumn AddImplementation(long value, bool inPlace = false)
@@ -147,6 +152,7 @@ internal Int64DataFrameColumn AddImplementation(long value, bool inPlace = false
             return newColumn;
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal UInt32DataFrameColumn AddImplementation(uint value, bool inPlace = false)
@@ -156,6 +162,7 @@ internal UInt32DataFrameColumn AddImplementation(uint value, bool inPlace = fals
             return newColumn;
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal UInt64DataFrameColumn AddImplementation(ulong value, bool inPlace = false)
@@ -165,6 +172,7 @@ internal UInt64DataFrameColumn AddImplementation(ulong value, bool inPlace = fal
             return newColumn;
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal DecimalDataFrameColumn ReverseAddImplementation(decimal value, bool inPlace = false)
@@ -174,6 +182,7 @@ internal DecimalDataFrameColumn ReverseAddImplementation(decimal value, bool inP
             return newColumn;
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal DoubleDataFrameColumn ReverseAddImplementation(double value, bool inPlace = false)
@@ -183,6 +192,7 @@ internal DoubleDataFrameColumn ReverseAddImplementation(double value, bool inPla
             return newColumn;
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal SingleDataFrameColumn ReverseAddImplementation(float value, bool inPlace = false)
@@ -192,6 +202,7 @@ internal SingleDataFrameColumn ReverseAddImplementation(float value, bool inPlac
             return newColumn;
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal Int32DataFrameColumn ReverseAddImplementation(int value, bool inPlace = false)
@@ -201,6 +212,7 @@ internal Int32DataFrameColumn ReverseAddImplementation(int value, bool inPlace =
             return newColumn;
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal Int64DataFrameColumn ReverseAddImplementation(long value, bool inPlace = false)
@@ -210,6 +222,7 @@ internal Int64DataFrameColumn ReverseAddImplementation(long value, bool inPlace
             return newColumn;
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal UInt32DataFrameColumn ReverseAddImplementation(uint value, bool inPlace = false)
@@ -219,6 +232,7 @@ internal UInt32DataFrameColumn ReverseAddImplementation(uint value, bool inPlace
             return newColumn;
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal UInt64DataFrameColumn ReverseAddImplementation(ulong value, bool inPlace = false)
@@ -319,6 +333,7 @@ internal UInt64DataFrameColumn SubtractImplementation(UInt64DataFrameColumn colu
             return newColumn;
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal DecimalDataFrameColumn SubtractImplementation(decimal value, bool inPlace = false)
@@ -328,6 +343,7 @@ internal DecimalDataFrameColumn SubtractImplementation(decimal value, bool inPla
             return newColumn;
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal DoubleDataFrameColumn SubtractImplementation(double value, bool inPlace = false)
@@ -337,6 +353,7 @@ internal DoubleDataFrameColumn SubtractImplementation(double value, bool inPlace
             return newColumn;
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal SingleDataFrameColumn SubtractImplementation(float value, bool inPlace = false)
@@ -346,6 +363,7 @@ internal SingleDataFrameColumn SubtractImplementation(float value, bool inPlace
             return newColumn;
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal Int32DataFrameColumn SubtractImplementation(int value, bool inPlace = false)
@@ -355,6 +373,7 @@ internal Int32DataFrameColumn SubtractImplementation(int value, bool inPlace = f
             return newColumn;
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal Int64DataFrameColumn SubtractImplementation(long value, bool inPlace = false)
@@ -364,6 +383,7 @@ internal Int64DataFrameColumn SubtractImplementation(long value, bool inPlace =
             return newColumn;
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal UInt32DataFrameColumn SubtractImplementation(uint value, bool inPlace = false)
@@ -373,6 +393,7 @@ internal UInt32DataFrameColumn SubtractImplementation(uint value, bool inPlace =
             return newColumn;
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal UInt64DataFrameColumn SubtractImplementation(ulong value, bool inPlace = false)
@@ -382,6 +403,7 @@ internal UInt64DataFrameColumn SubtractImplementation(ulong value, bool inPlace
             return newColumn;
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal DecimalDataFrameColumn ReverseSubtractImplementation(decimal value, bool inPlace = false)
@@ -391,6 +413,7 @@ internal DecimalDataFrameColumn ReverseSubtractImplementation(decimal value, boo
             return newColumn;
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal DoubleDataFrameColumn ReverseSubtractImplementation(double value, bool inPlace = false)
@@ -400,6 +423,7 @@ internal DoubleDataFrameColumn ReverseSubtractImplementation(double value, bool
             return newColumn;
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal SingleDataFrameColumn ReverseSubtractImplementation(float value, bool inPlace = false)
@@ -409,6 +433,7 @@ internal SingleDataFrameColumn ReverseSubtractImplementation(float value, bool i
             return newColumn;
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal Int32DataFrameColumn ReverseSubtractImplementation(int value, bool inPlace = false)
@@ -418,6 +443,7 @@ internal Int32DataFrameColumn ReverseSubtractImplementation(int value, bool inPl
             return newColumn;
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal Int64DataFrameColumn ReverseSubtractImplementation(long value, bool inPlace = false)
@@ -427,6 +453,7 @@ internal Int64DataFrameColumn ReverseSubtractImplementation(long value, bool inP
             return newColumn;
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal UInt32DataFrameColumn ReverseSubtractImplementation(uint value, bool inPlace = false)
@@ -436,6 +463,7 @@ internal UInt32DataFrameColumn ReverseSubtractImplementation(uint value, bool in
             return newColumn;
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal UInt64DataFrameColumn ReverseSubtractImplementation(ulong value, bool inPlace = false)
@@ -536,6 +564,7 @@ internal UInt64DataFrameColumn MultiplyImplementation(UInt64DataFrameColumn colu
             return newColumn;
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal DecimalDataFrameColumn MultiplyImplementation(decimal value, bool inPlace = false)
@@ -545,6 +574,7 @@ internal DecimalDataFrameColumn MultiplyImplementation(decimal value, bool inPla
             return newColumn;
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal DoubleDataFrameColumn MultiplyImplementation(double value, bool inPlace = false)
@@ -554,6 +584,7 @@ internal DoubleDataFrameColumn MultiplyImplementation(double value, bool inPlace
             return newColumn;
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal SingleDataFrameColumn MultiplyImplementation(float value, bool inPlace = false)
@@ -563,6 +594,7 @@ internal SingleDataFrameColumn MultiplyImplementation(float value, bool inPlace
             return newColumn;
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal Int32DataFrameColumn MultiplyImplementation(int value, bool inPlace = false)
@@ -572,6 +604,7 @@ internal Int32DataFrameColumn MultiplyImplementation(int value, bool inPlace = f
             return newColumn;
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal Int64DataFrameColumn MultiplyImplementation(long value, bool inPlace = false)
@@ -581,6 +614,7 @@ internal Int64DataFrameColumn MultiplyImplementation(long value, bool inPlace =
             return newColumn;
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal UInt32DataFrameColumn MultiplyImplementation(uint value, bool inPlace = false)
@@ -590,6 +624,7 @@ internal UInt32DataFrameColumn MultiplyImplementation(uint value, bool inPlace =
             return newColumn;
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal UInt64DataFrameColumn MultiplyImplementation(ulong value, bool inPlace = false)
@@ -599,6 +634,7 @@ internal UInt64DataFrameColumn MultiplyImplementation(ulong value, bool inPlace
             return newColumn;
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal DecimalDataFrameColumn ReverseMultiplyImplementation(decimal value, bool inPlace = false)
@@ -608,6 +644,7 @@ internal DecimalDataFrameColumn ReverseMultiplyImplementation(decimal value, boo
             return newColumn;
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal DoubleDataFrameColumn ReverseMultiplyImplementation(double value, bool inPlace = false)
@@ -617,6 +654,7 @@ internal DoubleDataFrameColumn ReverseMultiplyImplementation(double value, bool
             return newColumn;
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal SingleDataFrameColumn ReverseMultiplyImplementation(float value, bool inPlace = false)
@@ -626,6 +664,7 @@ internal SingleDataFrameColumn ReverseMultiplyImplementation(float value, bool i
             return newColumn;
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal Int32DataFrameColumn ReverseMultiplyImplementation(int value, bool inPlace = false)
@@ -635,6 +674,7 @@ internal Int32DataFrameColumn ReverseMultiplyImplementation(int value, bool inPl
             return newColumn;
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal Int64DataFrameColumn ReverseMultiplyImplementation(long value, bool inPlace = false)
@@ -644,6 +684,7 @@ internal Int64DataFrameColumn ReverseMultiplyImplementation(long value, bool inP
             return newColumn;
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal UInt32DataFrameColumn ReverseMultiplyImplementation(uint value, bool inPlace = false)
@@ -653,6 +694,7 @@ internal UInt32DataFrameColumn ReverseMultiplyImplementation(uint value, bool in
             return newColumn;
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal UInt64DataFrameColumn ReverseMultiplyImplementation(ulong value, bool inPlace = false)
@@ -753,6 +795,7 @@ internal UInt64DataFrameColumn DivideImplementation(UInt64DataFrameColumn column
             return newColumn;
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal DecimalDataFrameColumn DivideImplementation(decimal value, bool inPlace = false)
@@ -762,6 +805,7 @@ internal DecimalDataFrameColumn DivideImplementation(decimal value, bool inPlace
             return newColumn;
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal DoubleDataFrameColumn DivideImplementation(double value, bool inPlace = false)
@@ -771,6 +815,7 @@ internal DoubleDataFrameColumn DivideImplementation(double value, bool inPlace =
             return newColumn;
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal SingleDataFrameColumn DivideImplementation(float value, bool inPlace = false)
@@ -780,6 +825,7 @@ internal SingleDataFrameColumn DivideImplementation(float value, bool inPlace =
             return newColumn;
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal Int32DataFrameColumn DivideImplementation(int value, bool inPlace = false)
@@ -789,6 +835,7 @@ internal Int32DataFrameColumn DivideImplementation(int value, bool inPlace = fal
             return newColumn;
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal Int64DataFrameColumn DivideImplementation(long value, bool inPlace = false)
@@ -798,6 +845,7 @@ internal Int64DataFrameColumn DivideImplementation(long value, bool inPlace = fa
             return newColumn;
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal UInt32DataFrameColumn DivideImplementation(uint value, bool inPlace = false)
@@ -807,6 +855,7 @@ internal UInt32DataFrameColumn DivideImplementation(uint value, bool inPlace = f
             return newColumn;
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal UInt64DataFrameColumn DivideImplementation(ulong value, bool inPlace = false)
@@ -816,6 +865,7 @@ internal UInt64DataFrameColumn DivideImplementation(ulong value, bool inPlace =
             return newColumn;
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal DecimalDataFrameColumn ReverseDivideImplementation(decimal value, bool inPlace = false)
@@ -825,6 +875,7 @@ internal DecimalDataFrameColumn ReverseDivideImplementation(decimal value, bool
             return newColumn;
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal DoubleDataFrameColumn ReverseDivideImplementation(double value, bool inPlace = false)
@@ -834,6 +885,7 @@ internal DoubleDataFrameColumn ReverseDivideImplementation(double value, bool in
             return newColumn;
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal SingleDataFrameColumn ReverseDivideImplementation(float value, bool inPlace = false)
@@ -843,6 +895,7 @@ internal SingleDataFrameColumn ReverseDivideImplementation(float value, bool inP
             return newColumn;
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal Int32DataFrameColumn ReverseDivideImplementation(int value, bool inPlace = false)
@@ -852,6 +905,7 @@ internal Int32DataFrameColumn ReverseDivideImplementation(int value, bool inPlac
             return newColumn;
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal Int64DataFrameColumn ReverseDivideImplementation(long value, bool inPlace = false)
@@ -861,6 +915,7 @@ internal Int64DataFrameColumn ReverseDivideImplementation(long value, bool inPla
             return newColumn;
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal UInt32DataFrameColumn ReverseDivideImplementation(uint value, bool inPlace = false)
@@ -870,6 +925,7 @@ internal UInt32DataFrameColumn ReverseDivideImplementation(uint value, bool inPl
             return newColumn;
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal UInt64DataFrameColumn ReverseDivideImplementation(ulong value, bool inPlace = false)
@@ -970,6 +1026,7 @@ internal UInt64DataFrameColumn ModuloImplementation(UInt64DataFrameColumn column
             return newColumn;
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal DecimalDataFrameColumn ModuloImplementation(decimal value, bool inPlace = false)
@@ -979,6 +1036,7 @@ internal DecimalDataFrameColumn ModuloImplementation(decimal value, bool inPlace
             return newColumn;
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal DoubleDataFrameColumn ModuloImplementation(double value, bool inPlace = false)
@@ -988,6 +1046,7 @@ internal DoubleDataFrameColumn ModuloImplementation(double value, bool inPlace =
             return newColumn;
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal SingleDataFrameColumn ModuloImplementation(float value, bool inPlace = false)
@@ -997,6 +1056,7 @@ internal SingleDataFrameColumn ModuloImplementation(float value, bool inPlace =
             return newColumn;
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal Int32DataFrameColumn ModuloImplementation(int value, bool inPlace = false)
@@ -1006,6 +1066,7 @@ internal Int32DataFrameColumn ModuloImplementation(int value, bool inPlace = fal
             return newColumn;
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal Int64DataFrameColumn ModuloImplementation(long value, bool inPlace = false)
@@ -1015,6 +1076,7 @@ internal Int64DataFrameColumn ModuloImplementation(long value, bool inPlace = fa
             return newColumn;
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal UInt32DataFrameColumn ModuloImplementation(uint value, bool inPlace = false)
@@ -1024,6 +1086,7 @@ internal UInt32DataFrameColumn ModuloImplementation(uint value, bool inPlace = f
             return newColumn;
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal UInt64DataFrameColumn ModuloImplementation(ulong value, bool inPlace = false)
@@ -1033,6 +1096,7 @@ internal UInt64DataFrameColumn ModuloImplementation(ulong value, bool inPlace =
             return newColumn;
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal DecimalDataFrameColumn ReverseModuloImplementation(decimal value, bool inPlace = false)
@@ -1042,6 +1106,7 @@ internal DecimalDataFrameColumn ReverseModuloImplementation(decimal value, bool
             return newColumn;
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal DoubleDataFrameColumn ReverseModuloImplementation(double value, bool inPlace = false)
@@ -1051,6 +1116,7 @@ internal DoubleDataFrameColumn ReverseModuloImplementation(double value, bool in
             return newColumn;
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal SingleDataFrameColumn ReverseModuloImplementation(float value, bool inPlace = false)
@@ -1060,6 +1126,7 @@ internal SingleDataFrameColumn ReverseModuloImplementation(float value, bool inP
             return newColumn;
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal Int32DataFrameColumn ReverseModuloImplementation(int value, bool inPlace = false)
@@ -1069,6 +1136,7 @@ internal Int32DataFrameColumn ReverseModuloImplementation(int value, bool inPlac
             return newColumn;
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal Int64DataFrameColumn ReverseModuloImplementation(long value, bool inPlace = false)
@@ -1078,6 +1146,7 @@ internal Int64DataFrameColumn ReverseModuloImplementation(long value, bool inPla
             return newColumn;
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal UInt32DataFrameColumn ReverseModuloImplementation(uint value, bool inPlace = false)
@@ -1087,6 +1156,7 @@ internal UInt32DataFrameColumn ReverseModuloImplementation(uint value, bool inPl
             return newColumn;
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal UInt64DataFrameColumn ReverseModuloImplementation(ulong value, bool inPlace = false)
@@ -1096,1408 +1166,1252 @@ internal UInt64DataFrameColumn ReverseModuloImplementation(ulong value, bool inP
             return newColumn;
         }
     }
+
     public partial class BooleanDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(BooleanDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
         }
     }
+
     public partial class ByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(ByteDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(DecimalDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(DoubleDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(SingleDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(Int32DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(Int64DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
         }
     }
+
     public partial class SByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(SByteDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
         }
     }
+
     public partial class Int16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(Int16DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(UInt32DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(UInt64DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
         }
     }
+
     public partial class UInt16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(UInt16DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
         }
     }
+
     public partial class DateTimeDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(DateTimeDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(column.ColumnContainer));
         }
     }
+
     public partial class BooleanDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(bool value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
+
     public partial class ByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(byte value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(decimal value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(double value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(float value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(int value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(long value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
+
     public partial class SByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(sbyte value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
+
     public partial class Int16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(short value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(uint value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(ulong value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
+
     public partial class UInt16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(ushort value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
+
     public partial class DateTimeDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(DateTime value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
+
     public partial class BooleanDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(BooleanDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
         }
     }
+
     public partial class ByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(ByteDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(DecimalDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(DoubleDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(SingleDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(Int32DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(Int64DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
         }
     }
+
     public partial class SByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(SByteDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
         }
     }
+
     public partial class Int16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(Int16DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(UInt32DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(UInt64DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
         }
     }
+
     public partial class UInt16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(UInt16DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
         }
     }
+
     public partial class DateTimeDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(DateTimeDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(column.ColumnContainer));
         }
     }
+
     public partial class BooleanDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(bool value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
+
     public partial class ByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(byte value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(decimal value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(double value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(float value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(int value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(long value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
+
     public partial class SByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(sbyte value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
+
     public partial class Int16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(short value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(uint value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(ulong value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
+
     public partial class UInt16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(ushort value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
+
     public partial class DateTimeDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(DateTime value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseNotEquals(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
+
     public partial class BooleanDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(BooleanDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class ByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(ByteDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(DecimalDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(DoubleDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(SingleDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(Int32DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(Int64DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class SByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(SByteDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class Int16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(Int16DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(UInt32DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(UInt64DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class UInt16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(UInt16DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class DateTimeDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(DateTimeDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class BooleanDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(bool value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
+
     public partial class ByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(byte value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(decimal value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(double value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(float value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(int value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(long value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
+
     public partial class SByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(sbyte value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
+
     public partial class Int16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(short value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(uint value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(ulong value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
+
     public partial class UInt16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(ushort value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
+
     public partial class DateTimeDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(DateTime value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
+
     public partial class BooleanDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(BooleanDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class ByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(ByteDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(DecimalDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(DoubleDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(SingleDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(Int32DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(Int64DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class SByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(SByteDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class Int16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(Int16DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(UInt32DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(UInt64DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class UInt16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(UInt16DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class DateTimeDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(DateTimeDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(column.ColumnContainer));
         }
     }
+
     public partial class BooleanDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(bool value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
+
     public partial class ByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(byte value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(decimal value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(double value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(float value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(int value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(long value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
+
     public partial class SByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(sbyte value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
+
     public partial class Int16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(short value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(uint value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(ulong value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
+
     public partial class UInt16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(ushort value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
+
     public partial class DateTimeDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(DateTime value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThanOrEqual(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
+
     public partial class BooleanDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(BooleanDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
         }
     }
+
     public partial class ByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(ByteDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(DecimalDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(DoubleDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(SingleDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(Int32DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(Int64DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
         }
     }
+
     public partial class SByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(SByteDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
         }
     }
+
     public partial class Int16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(Int16DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(UInt32DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(UInt64DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
         }
     }
+
     public partial class UInt16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(UInt16DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
         }
     }
+
     public partial class DateTimeDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(DateTimeDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(column.ColumnContainer));
         }
     }
+
     public partial class BooleanDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(bool value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
+
     public partial class ByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(byte value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(decimal value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(double value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(float value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(int value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(long value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
+
     public partial class SByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(sbyte value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
+
     public partial class Int16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(short value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(uint value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(ulong value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
+
     public partial class UInt16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(ushort value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
+
     public partial class DateTimeDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(DateTime value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseGreaterThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
+
     public partial class BooleanDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(BooleanDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
         }
     }
+
     public partial class ByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(ByteDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(DecimalDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(DoubleDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(SingleDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(Int32DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(Int64DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
         }
     }
+
     public partial class SByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(SByteDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
         }
     }
+
     public partial class Int16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(Int16DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(UInt32DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(UInt64DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
         }
     }
+
     public partial class UInt16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(UInt16DataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
         }
     }
+
     public partial class DateTimeDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(DateTimeDataFrameColumn column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(column.ColumnContainer));
         }
     }
+
     public partial class BooleanDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(bool value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
+
     public partial class ByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(byte value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
+
     public partial class DecimalDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(decimal value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
+
     public partial class DoubleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(double value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
+
     public partial class SingleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(float value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
+
     public partial class Int32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(int value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
+
     public partial class Int64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(long value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
+
     public partial class SByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(sbyte value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
+
     public partial class Int16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(short value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
+
     public partial class UInt32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(uint value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
+
     public partial class UInt64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(ulong value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
+
     public partial class UInt16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(ushort value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
+
     public partial class DateTimeDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(DateTime value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.ElementwiseLessThan(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
 }
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt
index d71534742a..b71ba41c3b 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt
@@ -112,6 +112,7 @@ void GenerateAllBinaryScalarCombinationsForMethod(string inputMethodName)
     string methodName = inputMethodName;
     methodName += "Implementation";
 #>
+
     public partial class <#=fullColumnType#>
     {
 <#
@@ -161,13 +162,12 @@ void GenerateAllComparisonCombinationsForMethod(string inputMethodName)
     methodName += "Implementation";
 
 #>
+
     public partial class <#=fullColumnType#>
     {
         internal <#=fullReturnType#> <#=methodName#>(<#=fullOtherColumnType#> column)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.<#=inputMethodName#>(column.ColumnContainer, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn(Name, ColumnContainer.<#=inputMethodName#>(column.ColumnContainer));
         }
     }
 <# 
@@ -196,13 +196,12 @@ void GenerateAllComparisonScalarCombinationsForMethod(string inputMethodName)
     methodName += "Implementation";
 
 #>
+
     public partial class <#=fullColumnType#>
     {
         internal <#=fullReturnType#> <#=methodName#>(<#=otherColumnType#> value)
         {
-            BooleanDataFrameColumn newColumn = CloneAsBooleanColumn();
-            ColumnContainer.<#=inputMethodName#>(value, newColumn.ColumnContainer);
-            return newColumn;
+            return new BooleanDataFrameColumn (Name, ColumnContainer.<#=inputMethodName#>(value));
         }
     }
 <# 
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs
index d7dfd7fd67..8c976fbcaf 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs
@@ -39,18 +39,18 @@ internal interface IPrimitiveDataFrameColumnArithmetic<T>
         void Xor(T scalar, PrimitiveColumnContainer<T> column);
         void LeftShift(PrimitiveColumnContainer<T> column, int value);
         void RightShift(PrimitiveColumnContainer<T> column, int value);
-        void ElementwiseEquals(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        void ElementwiseEquals(PrimitiveColumnContainer<T> column, T scalar);
-        void ElementwiseNotEquals(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        void ElementwiseNotEquals(PrimitiveColumnContainer<T> column, T scalar);
-        void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<T> column, T scalar);
-        void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<T> column, T scalar);
-        void ElementwiseGreaterThan(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        void ElementwiseGreaterThan(PrimitiveColumnContainer<T> column, T scalar);
-        void ElementwiseLessThan(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
-        void ElementwiseLessThan(PrimitiveColumnContainer<T> column, T scalar);
+        PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
+        PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<T> column, T scalar);
+        PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
+        PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<T> column, T scalar);
+        PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
+        PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<T> column, T scalar);
+        PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
+        PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<T> column, T scalar);
+        PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
+        PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<T> column, T scalar);
+        PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<T> left, PrimitiveColumnContainer<T> right);
+        PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<T> column, T scalar);
     }
 
     internal static class PrimitiveDataFrameColumnArithmetic<T>
@@ -123,69 +123,84 @@ public static IPrimitiveDataFrameColumnArithmetic<T> GetArithmetic<T>()
             throw new NotSupportedException();
         }
     }
-
     internal class BoolArithmetic : IPrimitiveDataFrameColumnArithmetic<bool>
     {
+
         public void Add(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
             throw new NotSupportedException();
         }
+
         public void Add(PrimitiveColumnContainer<bool> column, bool scalar)
         {
             throw new NotSupportedException();
         }
+
         public void Add(bool scalar, PrimitiveColumnContainer<bool> column)
         {
             throw new NotSupportedException();
         }
+
         public void Subtract(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
             throw new NotSupportedException();
         }
+
         public void Subtract(PrimitiveColumnContainer<bool> column, bool scalar)
         {
             throw new NotSupportedException();
         }
+
         public void Subtract(bool scalar, PrimitiveColumnContainer<bool> column)
         {
             throw new NotSupportedException();
         }
+
         public void Multiply(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
             throw new NotSupportedException();
         }
+
         public void Multiply(PrimitiveColumnContainer<bool> column, bool scalar)
         {
             throw new NotSupportedException();
         }
+
         public void Multiply(bool scalar, PrimitiveColumnContainer<bool> column)
         {
             throw new NotSupportedException();
         }
+
         public void Divide(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
             throw new NotSupportedException();
         }
+
         public void Divide(PrimitiveColumnContainer<bool> column, bool scalar)
         {
             throw new NotSupportedException();
         }
+
         public void Divide(bool scalar, PrimitiveColumnContainer<bool> column)
         {
             throw new NotSupportedException();
         }
+
         public void Modulo(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
             throw new NotSupportedException();
         }
+
         public void Modulo(PrimitiveColumnContainer<bool> column, bool scalar)
         {
             throw new NotSupportedException();
         }
+
         public void Modulo(bool scalar, PrimitiveColumnContainer<bool> column)
         {
             throw new NotSupportedException();
         }
+
         public void And(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -199,6 +214,7 @@ public void And(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bo
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<bool> column, bool scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -211,6 +227,7 @@ public void And(PrimitiveColumnContainer<bool> column, bool scalar)
                 }
             }
         }
+
         public void And(bool scalar, PrimitiveColumnContainer<bool> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -223,6 +240,7 @@ public void And(bool scalar, PrimitiveColumnContainer<bool> column)
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -236,6 +254,7 @@ public void Or(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<boo
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<bool> column, bool scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -248,6 +267,7 @@ public void Or(PrimitiveColumnContainer<bool> column, bool scalar)
                 }
             }
         }
+
         public void Or(bool scalar, PrimitiveColumnContainer<bool> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -260,6 +280,7 @@ public void Or(bool scalar, PrimitiveColumnContainer<bool> column)
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -273,6 +294,7 @@ public void Xor(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bo
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<bool> column, bool scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -285,6 +307,7 @@ public void Xor(PrimitiveColumnContainer<bool> column, bool scalar)
                 }
             }
         }
+
         public void Xor(bool scalar, PrimitiveColumnContainer<bool> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -297,16 +320,20 @@ public void Xor(bool scalar, PrimitiveColumnContainer<bool> column)
                 }
             }
         }
+
         public void LeftShift(PrimitiveColumnContainer<bool> column, int value)
         {
             throw new NotSupportedException();
         }
+
         public void RightShift(PrimitiveColumnContainer<bool> column, int value)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -317,9 +344,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<bool> left, PrimitiveColu
                     ret[index++] = (span[i] == otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<bool> column, bool scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<bool> column, bool scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -329,9 +359,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<bool> column, bool scalar
                     ret[index++] = (span[i] == scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -342,9 +375,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<bool> left, PrimitiveC
                     ret[index++] = (span[i] != otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<bool> column, bool scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<bool> column, bool scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -354,42 +390,52 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<bool> column, bool sca
                     ret[index++] = (span[i] != scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<bool> column, bool scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<bool> column, bool scalar)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<bool> column, bool scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<bool> column, bool scalar)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<bool> column, bool scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<bool> column, bool scalar)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<bool> column, bool scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<bool> column, bool scalar)
         {
             throw new NotSupportedException();
         }
     }
     internal class ByteArithmetic : IPrimitiveDataFrameColumnArithmetic<byte>
     {
+
         public void Add(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -403,6 +449,7 @@ public void Add(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<by
                 }
             }
         }
+
         public void Add(PrimitiveColumnContainer<byte> column, byte scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -415,6 +462,7 @@ public void Add(PrimitiveColumnContainer<byte> column, byte scalar)
                 }
             }
         }
+
         public void Add(byte scalar, PrimitiveColumnContainer<byte> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -427,6 +475,7 @@ public void Add(byte scalar, PrimitiveColumnContainer<byte> column)
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -440,6 +489,7 @@ public void Subtract(PrimitiveColumnContainer<byte> left, PrimitiveColumnContain
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<byte> column, byte scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -452,6 +502,7 @@ public void Subtract(PrimitiveColumnContainer<byte> column, byte scalar)
                 }
             }
         }
+
         public void Subtract(byte scalar, PrimitiveColumnContainer<byte> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -464,6 +515,7 @@ public void Subtract(byte scalar, PrimitiveColumnContainer<byte> column)
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -477,6 +529,7 @@ public void Multiply(PrimitiveColumnContainer<byte> left, PrimitiveColumnContain
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<byte> column, byte scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -489,6 +542,7 @@ public void Multiply(PrimitiveColumnContainer<byte> column, byte scalar)
                 }
             }
         }
+
         public void Multiply(byte scalar, PrimitiveColumnContainer<byte> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -501,6 +555,7 @@ public void Multiply(byte scalar, PrimitiveColumnContainer<byte> column)
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -514,6 +569,7 @@ public void Divide(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<byte> column, byte scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -526,6 +582,7 @@ public void Divide(PrimitiveColumnContainer<byte> column, byte scalar)
                 }
             }
         }
+
         public void Divide(byte scalar, PrimitiveColumnContainer<byte> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -538,6 +595,7 @@ public void Divide(byte scalar, PrimitiveColumnContainer<byte> column)
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -551,6 +609,7 @@ public void Modulo(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<byte> column, byte scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -563,6 +622,7 @@ public void Modulo(PrimitiveColumnContainer<byte> column, byte scalar)
                 }
             }
         }
+
         public void Modulo(byte scalar, PrimitiveColumnContainer<byte> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -575,6 +635,7 @@ public void Modulo(byte scalar, PrimitiveColumnContainer<byte> column)
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -588,6 +649,7 @@ public void And(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<by
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<byte> column, byte scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -600,6 +662,7 @@ public void And(PrimitiveColumnContainer<byte> column, byte scalar)
                 }
             }
         }
+
         public void And(byte scalar, PrimitiveColumnContainer<byte> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -612,6 +675,7 @@ public void And(byte scalar, PrimitiveColumnContainer<byte> column)
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -625,6 +689,7 @@ public void Or(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byt
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<byte> column, byte scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -637,6 +702,7 @@ public void Or(PrimitiveColumnContainer<byte> column, byte scalar)
                 }
             }
         }
+
         public void Or(byte scalar, PrimitiveColumnContainer<byte> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -649,6 +715,7 @@ public void Or(byte scalar, PrimitiveColumnContainer<byte> column)
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -662,6 +729,7 @@ public void Xor(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<by
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<byte> column, byte scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -674,6 +742,7 @@ public void Xor(PrimitiveColumnContainer<byte> column, byte scalar)
                 }
             }
         }
+
         public void Xor(byte scalar, PrimitiveColumnContainer<byte> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -686,6 +755,7 @@ public void Xor(byte scalar, PrimitiveColumnContainer<byte> column)
                 }
             }
         }
+
         public void LeftShift(PrimitiveColumnContainer<byte> column, int value)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -698,6 +768,7 @@ public void LeftShift(PrimitiveColumnContainer<byte> column, int value)
                 }
             }
         }
+
         public void RightShift(PrimitiveColumnContainer<byte> column, int value)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -710,8 +781,10 @@ public void RightShift(PrimitiveColumnContainer<byte> column, int value)
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -722,9 +795,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<byte> left, PrimitiveColu
                     ret[index++] = (span[i] == otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<byte> column, byte scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<byte> column, byte scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -734,9 +810,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<byte> column, byte scalar
                     ret[index++] = (span[i] == scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -747,9 +826,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<byte> left, PrimitiveC
                     ret[index++] = (span[i] != otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<byte> column, byte scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<byte> column, byte scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -759,9 +841,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<byte> column, byte sca
                     ret[index++] = (span[i] != scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -772,9 +857,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<byte> left, P
                     ret[index++] = (span[i] >= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<byte> column, byte scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<byte> column, byte scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -784,9 +872,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<byte> column,
                     ret[index++] = (span[i] >= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -797,9 +888,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<byte> left, Prim
                     ret[index++] = (span[i] <= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<byte> column, byte scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<byte> column, byte scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -809,9 +903,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<byte> column, by
                     ret[index++] = (span[i] <= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -822,9 +919,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<byte> left, Primitiv
                     ret[index++] = (span[i] > otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<byte> column, byte scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<byte> column, byte scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -834,9 +934,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<byte> column, byte s
                     ret[index++] = (span[i] > scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -847,9 +950,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<byte> left, PrimitiveCo
                     ret[index++] = (span[i] < otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<byte> column, byte scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<byte> column, byte scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -859,10 +965,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<byte> column, byte scal
                     ret[index++] = (span[i] < scalar);
                 }
             }
+            return ret;
         }
     }
     internal class CharArithmetic : IPrimitiveDataFrameColumnArithmetic<char>
     {
+
         public void Add(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -876,6 +984,7 @@ public void Add(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<ch
                 }
             }
         }
+
         public void Add(PrimitiveColumnContainer<char> column, char scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -888,6 +997,7 @@ public void Add(PrimitiveColumnContainer<char> column, char scalar)
                 }
             }
         }
+
         public void Add(char scalar, PrimitiveColumnContainer<char> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -900,6 +1010,7 @@ public void Add(char scalar, PrimitiveColumnContainer<char> column)
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -913,6 +1024,7 @@ public void Subtract(PrimitiveColumnContainer<char> left, PrimitiveColumnContain
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<char> column, char scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -925,6 +1037,7 @@ public void Subtract(PrimitiveColumnContainer<char> column, char scalar)
                 }
             }
         }
+
         public void Subtract(char scalar, PrimitiveColumnContainer<char> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -937,6 +1050,7 @@ public void Subtract(char scalar, PrimitiveColumnContainer<char> column)
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -950,6 +1064,7 @@ public void Multiply(PrimitiveColumnContainer<char> left, PrimitiveColumnContain
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<char> column, char scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -962,6 +1077,7 @@ public void Multiply(PrimitiveColumnContainer<char> column, char scalar)
                 }
             }
         }
+
         public void Multiply(char scalar, PrimitiveColumnContainer<char> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -974,6 +1090,7 @@ public void Multiply(char scalar, PrimitiveColumnContainer<char> column)
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -987,6 +1104,7 @@ public void Divide(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<char> column, char scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -999,6 +1117,7 @@ public void Divide(PrimitiveColumnContainer<char> column, char scalar)
                 }
             }
         }
+
         public void Divide(char scalar, PrimitiveColumnContainer<char> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1011,6 +1130,7 @@ public void Divide(char scalar, PrimitiveColumnContainer<char> column)
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1024,6 +1144,7 @@ public void Modulo(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<char> column, char scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1036,6 +1157,7 @@ public void Modulo(PrimitiveColumnContainer<char> column, char scalar)
                 }
             }
         }
+
         public void Modulo(char scalar, PrimitiveColumnContainer<char> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1048,6 +1170,7 @@ public void Modulo(char scalar, PrimitiveColumnContainer<char> column)
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1061,6 +1184,7 @@ public void And(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<ch
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<char> column, char scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1073,6 +1197,7 @@ public void And(PrimitiveColumnContainer<char> column, char scalar)
                 }
             }
         }
+
         public void And(char scalar, PrimitiveColumnContainer<char> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1085,6 +1210,7 @@ public void And(char scalar, PrimitiveColumnContainer<char> column)
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1098,6 +1224,7 @@ public void Or(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<cha
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<char> column, char scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1110,6 +1237,7 @@ public void Or(PrimitiveColumnContainer<char> column, char scalar)
                 }
             }
         }
+
         public void Or(char scalar, PrimitiveColumnContainer<char> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1122,6 +1250,7 @@ public void Or(char scalar, PrimitiveColumnContainer<char> column)
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1135,6 +1264,7 @@ public void Xor(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<ch
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<char> column, char scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1147,6 +1277,7 @@ public void Xor(PrimitiveColumnContainer<char> column, char scalar)
                 }
             }
         }
+
         public void Xor(char scalar, PrimitiveColumnContainer<char> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1159,6 +1290,7 @@ public void Xor(char scalar, PrimitiveColumnContainer<char> column)
                 }
             }
         }
+
         public void LeftShift(PrimitiveColumnContainer<char> column, int value)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1171,6 +1303,7 @@ public void LeftShift(PrimitiveColumnContainer<char> column, int value)
                 }
             }
         }
+
         public void RightShift(PrimitiveColumnContainer<char> column, int value)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1183,8 +1316,10 @@ public void RightShift(PrimitiveColumnContainer<char> column, int value)
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1195,9 +1330,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<char> left, PrimitiveColu
                     ret[index++] = (span[i] == otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<char> column, char scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<char> column, char scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1207,9 +1345,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<char> column, char scalar
                     ret[index++] = (span[i] == scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1220,9 +1361,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<char> left, PrimitiveC
                     ret[index++] = (span[i] != otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<char> column, char scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<char> column, char scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1232,9 +1376,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<char> column, char sca
                     ret[index++] = (span[i] != scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1245,9 +1392,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<char> left, P
                     ret[index++] = (span[i] >= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<char> column, char scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<char> column, char scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1257,9 +1407,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<char> column,
                     ret[index++] = (span[i] >= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1270,9 +1423,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<char> left, Prim
                     ret[index++] = (span[i] <= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<char> column, char scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<char> column, char scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1282,9 +1438,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<char> column, ch
                     ret[index++] = (span[i] <= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1295,9 +1454,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<char> left, Primitiv
                     ret[index++] = (span[i] > otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<char> column, char scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<char> column, char scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1307,9 +1469,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<char> column, char s
                     ret[index++] = (span[i] > scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1320,9 +1485,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<char> left, PrimitiveCo
                     ret[index++] = (span[i] < otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<char> column, char scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<char> column, char scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1332,10 +1500,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<char> column, char scal
                     ret[index++] = (span[i] < scalar);
                 }
             }
+            return ret;
         }
     }
     internal class DecimalArithmetic : IPrimitiveDataFrameColumnArithmetic<decimal>
     {
+
         public void Add(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1349,6 +1519,7 @@ public void Add(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer
                 }
             }
         }
+
         public void Add(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1361,6 +1532,7 @@ public void Add(PrimitiveColumnContainer<decimal> column, decimal scalar)
                 }
             }
         }
+
         public void Add(decimal scalar, PrimitiveColumnContainer<decimal> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1373,6 +1545,7 @@ public void Add(decimal scalar, PrimitiveColumnContainer<decimal> column)
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1386,6 +1559,7 @@ public void Subtract(PrimitiveColumnContainer<decimal> left, PrimitiveColumnCont
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1398,6 +1572,7 @@ public void Subtract(PrimitiveColumnContainer<decimal> column, decimal scalar)
                 }
             }
         }
+
         public void Subtract(decimal scalar, PrimitiveColumnContainer<decimal> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1410,6 +1585,7 @@ public void Subtract(decimal scalar, PrimitiveColumnContainer<decimal> column)
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1423,6 +1599,7 @@ public void Multiply(PrimitiveColumnContainer<decimal> left, PrimitiveColumnCont
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1435,6 +1612,7 @@ public void Multiply(PrimitiveColumnContainer<decimal> column, decimal scalar)
                 }
             }
         }
+
         public void Multiply(decimal scalar, PrimitiveColumnContainer<decimal> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1447,6 +1625,7 @@ public void Multiply(decimal scalar, PrimitiveColumnContainer<decimal> column)
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1460,6 +1639,7 @@ public void Divide(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContai
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1472,6 +1652,7 @@ public void Divide(PrimitiveColumnContainer<decimal> column, decimal scalar)
                 }
             }
         }
+
         public void Divide(decimal scalar, PrimitiveColumnContainer<decimal> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1484,6 +1665,7 @@ public void Divide(decimal scalar, PrimitiveColumnContainer<decimal> column)
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1497,6 +1679,7 @@ public void Modulo(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContai
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1509,6 +1692,7 @@ public void Modulo(PrimitiveColumnContainer<decimal> column, decimal scalar)
                 }
             }
         }
+
         public void Modulo(decimal scalar, PrimitiveColumnContainer<decimal> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1521,52 +1705,65 @@ public void Modulo(decimal scalar, PrimitiveColumnContainer<decimal> column)
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
             throw new NotSupportedException();
         }
+
         public void And(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
             throw new NotSupportedException();
         }
+
         public void And(decimal scalar, PrimitiveColumnContainer<decimal> column)
         {
             throw new NotSupportedException();
         }
+
         public void Or(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
             throw new NotSupportedException();
         }
+
         public void Or(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
             throw new NotSupportedException();
         }
+
         public void Or(decimal scalar, PrimitiveColumnContainer<decimal> column)
         {
             throw new NotSupportedException();
         }
+
         public void Xor(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
             throw new NotSupportedException();
         }
+
         public void Xor(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
             throw new NotSupportedException();
         }
+
         public void Xor(decimal scalar, PrimitiveColumnContainer<decimal> column)
         {
             throw new NotSupportedException();
         }
+
         public void LeftShift(PrimitiveColumnContainer<decimal> column, int value)
         {
             throw new NotSupportedException();
         }
+
         public void RightShift(PrimitiveColumnContainer<decimal> column, int value)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1577,9 +1774,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<decimal> left, PrimitiveC
                     ret[index++] = (span[i] == otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<decimal> column, decimal scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1589,9 +1789,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<decimal> column, decimal
                     ret[index++] = (span[i] == scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1602,9 +1805,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<decimal> left, Primiti
                     ret[index++] = (span[i] != otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<decimal> column, decimal scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1614,9 +1820,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<decimal> column, decim
                     ret[index++] = (span[i] != scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1627,9 +1836,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<decimal> left
                     ret[index++] = (span[i] >= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<decimal> column, decimal scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1639,9 +1851,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<decimal> colu
                     ret[index++] = (span[i] >= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1652,9 +1867,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<decimal> left, P
                     ret[index++] = (span[i] <= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<decimal> column, decimal scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1664,9 +1882,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<decimal> column,
                     ret[index++] = (span[i] <= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1677,9 +1898,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<decimal> left, Primi
                     ret[index++] = (span[i] > otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<decimal> column, decimal scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1689,9 +1913,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<decimal> column, dec
                     ret[index++] = (span[i] > scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1702,9 +1929,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<decimal> left, Primitiv
                     ret[index++] = (span[i] < otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<decimal> column, decimal scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1714,10 +1944,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<decimal> column, decima
                     ret[index++] = (span[i] < scalar);
                 }
             }
+            return ret;
         }
     }
     internal class DoubleArithmetic : IPrimitiveDataFrameColumnArithmetic<double>
     {
+
         public void Add(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1731,6 +1963,7 @@ public void Add(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<
                 }
             }
         }
+
         public void Add(PrimitiveColumnContainer<double> column, double scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1743,6 +1976,7 @@ public void Add(PrimitiveColumnContainer<double> column, double scalar)
                 }
             }
         }
+
         public void Add(double scalar, PrimitiveColumnContainer<double> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1755,6 +1989,7 @@ public void Add(double scalar, PrimitiveColumnContainer<double> column)
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1768,6 +2003,7 @@ public void Subtract(PrimitiveColumnContainer<double> left, PrimitiveColumnConta
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<double> column, double scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1780,6 +2016,7 @@ public void Subtract(PrimitiveColumnContainer<double> column, double scalar)
                 }
             }
         }
+
         public void Subtract(double scalar, PrimitiveColumnContainer<double> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1792,6 +2029,7 @@ public void Subtract(double scalar, PrimitiveColumnContainer<double> column)
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1805,6 +2043,7 @@ public void Multiply(PrimitiveColumnContainer<double> left, PrimitiveColumnConta
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<double> column, double scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1817,6 +2056,7 @@ public void Multiply(PrimitiveColumnContainer<double> column, double scalar)
                 }
             }
         }
+
         public void Multiply(double scalar, PrimitiveColumnContainer<double> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1829,6 +2069,7 @@ public void Multiply(double scalar, PrimitiveColumnContainer<double> column)
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1842,6 +2083,7 @@ public void Divide(PrimitiveColumnContainer<double> left, PrimitiveColumnContain
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<double> column, double scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1854,6 +2096,7 @@ public void Divide(PrimitiveColumnContainer<double> column, double scalar)
                 }
             }
         }
+
         public void Divide(double scalar, PrimitiveColumnContainer<double> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1866,6 +2109,7 @@ public void Divide(double scalar, PrimitiveColumnContainer<double> column)
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -1879,6 +2123,7 @@ public void Modulo(PrimitiveColumnContainer<double> left, PrimitiveColumnContain
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<double> column, double scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1891,6 +2136,7 @@ public void Modulo(PrimitiveColumnContainer<double> column, double scalar)
                 }
             }
         }
+
         public void Modulo(double scalar, PrimitiveColumnContainer<double> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -1903,52 +2149,65 @@ public void Modulo(double scalar, PrimitiveColumnContainer<double> column)
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
             throw new NotSupportedException();
         }
+
         public void And(PrimitiveColumnContainer<double> column, double scalar)
         {
             throw new NotSupportedException();
         }
+
         public void And(double scalar, PrimitiveColumnContainer<double> column)
         {
             throw new NotSupportedException();
         }
+
         public void Or(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
             throw new NotSupportedException();
         }
+
         public void Or(PrimitiveColumnContainer<double> column, double scalar)
         {
             throw new NotSupportedException();
         }
+
         public void Or(double scalar, PrimitiveColumnContainer<double> column)
         {
             throw new NotSupportedException();
         }
+
         public void Xor(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
             throw new NotSupportedException();
         }
+
         public void Xor(PrimitiveColumnContainer<double> column, double scalar)
         {
             throw new NotSupportedException();
         }
+
         public void Xor(double scalar, PrimitiveColumnContainer<double> column)
         {
             throw new NotSupportedException();
         }
+
         public void LeftShift(PrimitiveColumnContainer<double> column, int value)
         {
             throw new NotSupportedException();
         }
+
         public void RightShift(PrimitiveColumnContainer<double> column, int value)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1959,9 +2218,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<double> left, PrimitiveCo
                     ret[index++] = (span[i] == otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<double> column, double scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<double> column, double scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1971,9 +2233,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<double> column, double sc
                     ret[index++] = (span[i] == scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1984,9 +2249,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<double> left, Primitiv
                     ret[index++] = (span[i] != otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<double> column, double scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<double> column, double scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1996,9 +2264,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<double> column, double
                     ret[index++] = (span[i] != scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2009,9 +2280,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<double> left,
                     ret[index++] = (span[i] >= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<double> column, double scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<double> column, double scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2021,9 +2295,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<double> colum
                     ret[index++] = (span[i] >= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2034,9 +2311,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<double> left, Pr
                     ret[index++] = (span[i] <= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<double> column, double scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<double> column, double scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2046,9 +2326,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<double> column,
                     ret[index++] = (span[i] <= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2059,9 +2342,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<double> left, Primit
                     ret[index++] = (span[i] > otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<double> column, double scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<double> column, double scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2071,9 +2357,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<double> column, doub
                     ret[index++] = (span[i] > scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2084,9 +2373,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<double> left, Primitive
                     ret[index++] = (span[i] < otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<double> column, double scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<double> column, double scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2096,10 +2388,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<double> column, double
                     ret[index++] = (span[i] < scalar);
                 }
             }
+            return ret;
         }
     }
     internal class FloatArithmetic : IPrimitiveDataFrameColumnArithmetic<float>
     {
+
         public void Add(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2113,6 +2407,7 @@ public void Add(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<f
                 }
             }
         }
+
         public void Add(PrimitiveColumnContainer<float> column, float scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2125,6 +2420,7 @@ public void Add(PrimitiveColumnContainer<float> column, float scalar)
                 }
             }
         }
+
         public void Add(float scalar, PrimitiveColumnContainer<float> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2137,6 +2433,7 @@ public void Add(float scalar, PrimitiveColumnContainer<float> column)
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2150,6 +2447,7 @@ public void Subtract(PrimitiveColumnContainer<float> left, PrimitiveColumnContai
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<float> column, float scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2162,6 +2460,7 @@ public void Subtract(PrimitiveColumnContainer<float> column, float scalar)
                 }
             }
         }
+
         public void Subtract(float scalar, PrimitiveColumnContainer<float> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2174,6 +2473,7 @@ public void Subtract(float scalar, PrimitiveColumnContainer<float> column)
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2187,6 +2487,7 @@ public void Multiply(PrimitiveColumnContainer<float> left, PrimitiveColumnContai
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<float> column, float scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2199,6 +2500,7 @@ public void Multiply(PrimitiveColumnContainer<float> column, float scalar)
                 }
             }
         }
+
         public void Multiply(float scalar, PrimitiveColumnContainer<float> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2211,6 +2513,7 @@ public void Multiply(float scalar, PrimitiveColumnContainer<float> column)
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2224,6 +2527,7 @@ public void Divide(PrimitiveColumnContainer<float> left, PrimitiveColumnContaine
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<float> column, float scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2236,6 +2540,7 @@ public void Divide(PrimitiveColumnContainer<float> column, float scalar)
                 }
             }
         }
+
         public void Divide(float scalar, PrimitiveColumnContainer<float> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2248,6 +2553,7 @@ public void Divide(float scalar, PrimitiveColumnContainer<float> column)
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2261,6 +2567,7 @@ public void Modulo(PrimitiveColumnContainer<float> left, PrimitiveColumnContaine
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<float> column, float scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2273,6 +2580,7 @@ public void Modulo(PrimitiveColumnContainer<float> column, float scalar)
                 }
             }
         }
+
         public void Modulo(float scalar, PrimitiveColumnContainer<float> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2285,52 +2593,65 @@ public void Modulo(float scalar, PrimitiveColumnContainer<float> column)
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
             throw new NotSupportedException();
         }
+
         public void And(PrimitiveColumnContainer<float> column, float scalar)
         {
             throw new NotSupportedException();
         }
+
         public void And(float scalar, PrimitiveColumnContainer<float> column)
         {
             throw new NotSupportedException();
         }
+
         public void Or(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
             throw new NotSupportedException();
         }
+
         public void Or(PrimitiveColumnContainer<float> column, float scalar)
         {
             throw new NotSupportedException();
         }
+
         public void Or(float scalar, PrimitiveColumnContainer<float> column)
         {
             throw new NotSupportedException();
         }
+
         public void Xor(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
             throw new NotSupportedException();
         }
+
         public void Xor(PrimitiveColumnContainer<float> column, float scalar)
         {
             throw new NotSupportedException();
         }
+
         public void Xor(float scalar, PrimitiveColumnContainer<float> column)
         {
             throw new NotSupportedException();
         }
+
         public void LeftShift(PrimitiveColumnContainer<float> column, int value)
         {
             throw new NotSupportedException();
         }
+
         public void RightShift(PrimitiveColumnContainer<float> column, int value)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2341,9 +2662,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<float> left, PrimitiveCol
                     ret[index++] = (span[i] == otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<float> column, float scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<float> column, float scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2353,9 +2677,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<float> column, float scal
                     ret[index++] = (span[i] == scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2366,9 +2693,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<float> left, Primitive
                     ret[index++] = (span[i] != otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<float> column, float scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<float> column, float scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2378,9 +2708,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<float> column, float s
                     ret[index++] = (span[i] != scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2391,9 +2724,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<float> left,
                     ret[index++] = (span[i] >= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<float> column, float scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<float> column, float scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2403,9 +2739,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<float> column
                     ret[index++] = (span[i] >= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2416,9 +2755,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<float> left, Pri
                     ret[index++] = (span[i] <= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<float> column, float scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<float> column, float scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2428,9 +2770,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<float> column, f
                     ret[index++] = (span[i] <= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2441,9 +2786,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<float> left, Primiti
                     ret[index++] = (span[i] > otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<float> column, float scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<float> column, float scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2453,9 +2801,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<float> column, float
                     ret[index++] = (span[i] > scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2466,9 +2817,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<float> left, PrimitiveC
                     ret[index++] = (span[i] < otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<float> column, float scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<float> column, float scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2478,10 +2832,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<float> column, float sc
                     ret[index++] = (span[i] < scalar);
                 }
             }
+            return ret;
         }
     }
     internal class IntArithmetic : IPrimitiveDataFrameColumnArithmetic<int>
     {
+
         public void Add(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2495,6 +2851,7 @@ public void Add(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int
                 }
             }
         }
+
         public void Add(PrimitiveColumnContainer<int> column, int scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2507,6 +2864,7 @@ public void Add(PrimitiveColumnContainer<int> column, int scalar)
                 }
             }
         }
+
         public void Add(int scalar, PrimitiveColumnContainer<int> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2519,6 +2877,7 @@ public void Add(int scalar, PrimitiveColumnContainer<int> column)
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2532,6 +2891,7 @@ public void Subtract(PrimitiveColumnContainer<int> left, PrimitiveColumnContaine
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<int> column, int scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2544,6 +2904,7 @@ public void Subtract(PrimitiveColumnContainer<int> column, int scalar)
                 }
             }
         }
+
         public void Subtract(int scalar, PrimitiveColumnContainer<int> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2556,6 +2917,7 @@ public void Subtract(int scalar, PrimitiveColumnContainer<int> column)
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2569,6 +2931,7 @@ public void Multiply(PrimitiveColumnContainer<int> left, PrimitiveColumnContaine
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<int> column, int scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2581,6 +2944,7 @@ public void Multiply(PrimitiveColumnContainer<int> column, int scalar)
                 }
             }
         }
+
         public void Multiply(int scalar, PrimitiveColumnContainer<int> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2593,6 +2957,7 @@ public void Multiply(int scalar, PrimitiveColumnContainer<int> column)
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2606,6 +2971,7 @@ public void Divide(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<int> column, int scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2618,6 +2984,7 @@ public void Divide(PrimitiveColumnContainer<int> column, int scalar)
                 }
             }
         }
+
         public void Divide(int scalar, PrimitiveColumnContainer<int> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2630,6 +2997,7 @@ public void Divide(int scalar, PrimitiveColumnContainer<int> column)
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2643,6 +3011,7 @@ public void Modulo(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<int> column, int scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2655,6 +3024,7 @@ public void Modulo(PrimitiveColumnContainer<int> column, int scalar)
                 }
             }
         }
+
         public void Modulo(int scalar, PrimitiveColumnContainer<int> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2667,6 +3037,7 @@ public void Modulo(int scalar, PrimitiveColumnContainer<int> column)
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2680,6 +3051,7 @@ public void And(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<int> column, int scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2692,6 +3064,7 @@ public void And(PrimitiveColumnContainer<int> column, int scalar)
                 }
             }
         }
+
         public void And(int scalar, PrimitiveColumnContainer<int> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2704,6 +3077,7 @@ public void And(int scalar, PrimitiveColumnContainer<int> column)
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2717,6 +3091,7 @@ public void Or(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int>
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<int> column, int scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2729,6 +3104,7 @@ public void Or(PrimitiveColumnContainer<int> column, int scalar)
                 }
             }
         }
+
         public void Or(int scalar, PrimitiveColumnContainer<int> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2741,6 +3117,7 @@ public void Or(int scalar, PrimitiveColumnContainer<int> column)
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2754,6 +3131,7 @@ public void Xor(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<int> column, int scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2766,6 +3144,7 @@ public void Xor(PrimitiveColumnContainer<int> column, int scalar)
                 }
             }
         }
+
         public void Xor(int scalar, PrimitiveColumnContainer<int> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2778,6 +3157,7 @@ public void Xor(int scalar, PrimitiveColumnContainer<int> column)
                 }
             }
         }
+
         public void LeftShift(PrimitiveColumnContainer<int> column, int value)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2790,6 +3170,7 @@ public void LeftShift(PrimitiveColumnContainer<int> column, int value)
                 }
             }
         }
+
         public void RightShift(PrimitiveColumnContainer<int> column, int value)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2802,8 +3183,10 @@ public void RightShift(PrimitiveColumnContainer<int> column, int value)
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2814,9 +3197,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<int> left, PrimitiveColum
                     ret[index++] = (span[i] == otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<int> column, int scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<int> column, int scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2826,9 +3212,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<int> column, int scalar)
                     ret[index++] = (span[i] == scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2839,9 +3228,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<int> left, PrimitiveCo
                     ret[index++] = (span[i] != otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<int> column, int scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<int> column, int scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2851,9 +3243,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<int> column, int scala
                     ret[index++] = (span[i] != scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2864,9 +3259,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<int> left, Pr
                     ret[index++] = (span[i] >= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<int> column, int scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<int> column, int scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2876,9 +3274,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<int> column,
                     ret[index++] = (span[i] >= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2889,9 +3290,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<int> left, Primi
                     ret[index++] = (span[i] <= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<int> column, int scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<int> column, int scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2901,9 +3305,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<int> column, int
                     ret[index++] = (span[i] <= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2914,9 +3321,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<int> left, Primitive
                     ret[index++] = (span[i] > otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<int> column, int scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<int> column, int scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2926,9 +3336,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<int> column, int sca
                     ret[index++] = (span[i] > scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2939,9 +3352,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<int> left, PrimitiveCol
                     ret[index++] = (span[i] < otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<int> column, int scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<int> column, int scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2951,10 +3367,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<int> column, int scalar
                     ret[index++] = (span[i] < scalar);
                 }
             }
+            return ret;
         }
     }
     internal class LongArithmetic : IPrimitiveDataFrameColumnArithmetic<long>
     {
+
         public void Add(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -2968,6 +3386,7 @@ public void Add(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<lo
                 }
             }
         }
+
         public void Add(PrimitiveColumnContainer<long> column, long scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2980,6 +3399,7 @@ public void Add(PrimitiveColumnContainer<long> column, long scalar)
                 }
             }
         }
+
         public void Add(long scalar, PrimitiveColumnContainer<long> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -2992,6 +3412,7 @@ public void Add(long scalar, PrimitiveColumnContainer<long> column)
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3005,6 +3426,7 @@ public void Subtract(PrimitiveColumnContainer<long> left, PrimitiveColumnContain
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<long> column, long scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3017,6 +3439,7 @@ public void Subtract(PrimitiveColumnContainer<long> column, long scalar)
                 }
             }
         }
+
         public void Subtract(long scalar, PrimitiveColumnContainer<long> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3029,6 +3452,7 @@ public void Subtract(long scalar, PrimitiveColumnContainer<long> column)
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3042,6 +3466,7 @@ public void Multiply(PrimitiveColumnContainer<long> left, PrimitiveColumnContain
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<long> column, long scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3054,6 +3479,7 @@ public void Multiply(PrimitiveColumnContainer<long> column, long scalar)
                 }
             }
         }
+
         public void Multiply(long scalar, PrimitiveColumnContainer<long> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3066,6 +3492,7 @@ public void Multiply(long scalar, PrimitiveColumnContainer<long> column)
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3079,6 +3506,7 @@ public void Divide(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<long> column, long scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3091,6 +3519,7 @@ public void Divide(PrimitiveColumnContainer<long> column, long scalar)
                 }
             }
         }
+
         public void Divide(long scalar, PrimitiveColumnContainer<long> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3103,6 +3532,7 @@ public void Divide(long scalar, PrimitiveColumnContainer<long> column)
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3116,6 +3546,7 @@ public void Modulo(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<long> column, long scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3128,6 +3559,7 @@ public void Modulo(PrimitiveColumnContainer<long> column, long scalar)
                 }
             }
         }
+
         public void Modulo(long scalar, PrimitiveColumnContainer<long> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3140,6 +3572,7 @@ public void Modulo(long scalar, PrimitiveColumnContainer<long> column)
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3153,6 +3586,7 @@ public void And(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<lo
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<long> column, long scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3165,6 +3599,7 @@ public void And(PrimitiveColumnContainer<long> column, long scalar)
                 }
             }
         }
+
         public void And(long scalar, PrimitiveColumnContainer<long> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3177,6 +3612,7 @@ public void And(long scalar, PrimitiveColumnContainer<long> column)
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3190,6 +3626,7 @@ public void Or(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<lon
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<long> column, long scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3202,6 +3639,7 @@ public void Or(PrimitiveColumnContainer<long> column, long scalar)
                 }
             }
         }
+
         public void Or(long scalar, PrimitiveColumnContainer<long> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3214,6 +3652,7 @@ public void Or(long scalar, PrimitiveColumnContainer<long> column)
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3227,6 +3666,7 @@ public void Xor(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<lo
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<long> column, long scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3239,6 +3679,7 @@ public void Xor(PrimitiveColumnContainer<long> column, long scalar)
                 }
             }
         }
+
         public void Xor(long scalar, PrimitiveColumnContainer<long> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3251,6 +3692,7 @@ public void Xor(long scalar, PrimitiveColumnContainer<long> column)
                 }
             }
         }
+
         public void LeftShift(PrimitiveColumnContainer<long> column, int value)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3263,6 +3705,7 @@ public void LeftShift(PrimitiveColumnContainer<long> column, int value)
                 }
             }
         }
+
         public void RightShift(PrimitiveColumnContainer<long> column, int value)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3275,8 +3718,10 @@ public void RightShift(PrimitiveColumnContainer<long> column, int value)
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3287,9 +3732,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<long> left, PrimitiveColu
                     ret[index++] = (span[i] == otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<long> column, long scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<long> column, long scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3299,9 +3747,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<long> column, long scalar
                     ret[index++] = (span[i] == scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3312,9 +3763,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<long> left, PrimitiveC
                     ret[index++] = (span[i] != otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<long> column, long scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<long> column, long scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3324,9 +3778,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<long> column, long sca
                     ret[index++] = (span[i] != scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3337,9 +3794,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<long> left, P
                     ret[index++] = (span[i] >= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<long> column, long scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<long> column, long scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3349,9 +3809,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<long> column,
                     ret[index++] = (span[i] >= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3362,9 +3825,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<long> left, Prim
                     ret[index++] = (span[i] <= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<long> column, long scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<long> column, long scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3374,9 +3840,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<long> column, lo
                     ret[index++] = (span[i] <= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3387,9 +3856,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<long> left, Primitiv
                     ret[index++] = (span[i] > otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<long> column, long scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<long> column, long scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3399,9 +3871,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<long> column, long s
                     ret[index++] = (span[i] > scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3412,9 +3887,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<long> left, PrimitiveCo
                     ret[index++] = (span[i] < otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<long> column, long scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<long> column, long scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3424,10 +3902,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<long> column, long scal
                     ret[index++] = (span[i] < scalar);
                 }
             }
+            return ret;
         }
     }
     internal class SByteArithmetic : IPrimitiveDataFrameColumnArithmetic<sbyte>
     {
+
         public void Add(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3441,6 +3921,7 @@ public void Add(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<s
                 }
             }
         }
+
         public void Add(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3453,6 +3934,7 @@ public void Add(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
                 }
             }
         }
+
         public void Add(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3465,6 +3947,7 @@ public void Add(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3478,6 +3961,7 @@ public void Subtract(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContai
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3490,6 +3974,7 @@ public void Subtract(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
                 }
             }
         }
+
         public void Subtract(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3502,6 +3987,7 @@ public void Subtract(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3515,6 +4001,7 @@ public void Multiply(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContai
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3527,6 +4014,7 @@ public void Multiply(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
                 }
             }
         }
+
         public void Multiply(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3539,6 +4027,7 @@ public void Multiply(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3552,6 +4041,7 @@ public void Divide(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContaine
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3564,6 +4054,7 @@ public void Divide(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
                 }
             }
         }
+
         public void Divide(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3576,6 +4067,7 @@ public void Divide(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3589,6 +4081,7 @@ public void Modulo(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContaine
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3601,6 +4094,7 @@ public void Modulo(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
                 }
             }
         }
+
         public void Modulo(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3613,6 +4107,7 @@ public void Modulo(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3626,6 +4121,7 @@ public void And(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<s
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3638,6 +4134,7 @@ public void And(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
                 }
             }
         }
+
         public void And(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3650,6 +4147,7 @@ public void And(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3663,6 +4161,7 @@ public void Or(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sb
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3675,6 +4174,7 @@ public void Or(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
                 }
             }
         }
+
         public void Or(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3687,6 +4187,7 @@ public void Or(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3700,6 +4201,7 @@ public void Xor(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<s
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3712,6 +4214,7 @@ public void Xor(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
                 }
             }
         }
+
         public void Xor(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3724,6 +4227,7 @@ public void Xor(sbyte scalar, PrimitiveColumnContainer<sbyte> column)
                 }
             }
         }
+
         public void LeftShift(PrimitiveColumnContainer<sbyte> column, int value)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3736,6 +4240,7 @@ public void LeftShift(PrimitiveColumnContainer<sbyte> column, int value)
                 }
             }
         }
+
         public void RightShift(PrimitiveColumnContainer<sbyte> column, int value)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3748,8 +4253,10 @@ public void RightShift(PrimitiveColumnContainer<sbyte> column, int value)
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3760,9 +4267,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<sbyte> left, PrimitiveCol
                     ret[index++] = (span[i] == otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3772,9 +4282,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<sbyte> column, sbyte scal
                     ret[index++] = (span[i] == scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3785,9 +4298,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<sbyte> left, Primitive
                     ret[index++] = (span[i] != otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3797,9 +4313,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<sbyte> column, sbyte s
                     ret[index++] = (span[i] != scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3810,9 +4329,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<sbyte> left,
                     ret[index++] = (span[i] >= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3822,9 +4344,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<sbyte> column
                     ret[index++] = (span[i] >= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3835,9 +4360,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<sbyte> left, Pri
                     ret[index++] = (span[i] <= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3847,9 +4375,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<sbyte> column, s
                     ret[index++] = (span[i] <= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3860,9 +4391,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<sbyte> left, Primiti
                     ret[index++] = (span[i] > otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3872,9 +4406,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<sbyte> column, sbyte
                     ret[index++] = (span[i] > scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3885,9 +4422,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<sbyte> left, PrimitiveC
                     ret[index++] = (span[i] < otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3897,10 +4437,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<sbyte> column, sbyte sc
                     ret[index++] = (span[i] < scalar);
                 }
             }
+            return ret;
         }
     }
     internal class ShortArithmetic : IPrimitiveDataFrameColumnArithmetic<short>
     {
+
         public void Add(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3914,6 +4456,7 @@ public void Add(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<s
                 }
             }
         }
+
         public void Add(PrimitiveColumnContainer<short> column, short scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3926,6 +4469,7 @@ public void Add(PrimitiveColumnContainer<short> column, short scalar)
                 }
             }
         }
+
         public void Add(short scalar, PrimitiveColumnContainer<short> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3938,6 +4482,7 @@ public void Add(short scalar, PrimitiveColumnContainer<short> column)
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3951,6 +4496,7 @@ public void Subtract(PrimitiveColumnContainer<short> left, PrimitiveColumnContai
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<short> column, short scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3963,6 +4509,7 @@ public void Subtract(PrimitiveColumnContainer<short> column, short scalar)
                 }
             }
         }
+
         public void Subtract(short scalar, PrimitiveColumnContainer<short> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -3975,6 +4522,7 @@ public void Subtract(short scalar, PrimitiveColumnContainer<short> column)
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -3988,6 +4536,7 @@ public void Multiply(PrimitiveColumnContainer<short> left, PrimitiveColumnContai
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<short> column, short scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4000,6 +4549,7 @@ public void Multiply(PrimitiveColumnContainer<short> column, short scalar)
                 }
             }
         }
+
         public void Multiply(short scalar, PrimitiveColumnContainer<short> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4012,6 +4562,7 @@ public void Multiply(short scalar, PrimitiveColumnContainer<short> column)
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4025,6 +4576,7 @@ public void Divide(PrimitiveColumnContainer<short> left, PrimitiveColumnContaine
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<short> column, short scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4037,6 +4589,7 @@ public void Divide(PrimitiveColumnContainer<short> column, short scalar)
                 }
             }
         }
+
         public void Divide(short scalar, PrimitiveColumnContainer<short> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4049,6 +4602,7 @@ public void Divide(short scalar, PrimitiveColumnContainer<short> column)
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4062,6 +4616,7 @@ public void Modulo(PrimitiveColumnContainer<short> left, PrimitiveColumnContaine
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<short> column, short scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4074,6 +4629,7 @@ public void Modulo(PrimitiveColumnContainer<short> column, short scalar)
                 }
             }
         }
+
         public void Modulo(short scalar, PrimitiveColumnContainer<short> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4086,6 +4642,7 @@ public void Modulo(short scalar, PrimitiveColumnContainer<short> column)
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4099,6 +4656,7 @@ public void And(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<s
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<short> column, short scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4111,6 +4669,7 @@ public void And(PrimitiveColumnContainer<short> column, short scalar)
                 }
             }
         }
+
         public void And(short scalar, PrimitiveColumnContainer<short> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4123,6 +4682,7 @@ public void And(short scalar, PrimitiveColumnContainer<short> column)
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4136,6 +4696,7 @@ public void Or(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<sh
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<short> column, short scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4148,6 +4709,7 @@ public void Or(PrimitiveColumnContainer<short> column, short scalar)
                 }
             }
         }
+
         public void Or(short scalar, PrimitiveColumnContainer<short> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4160,6 +4722,7 @@ public void Or(short scalar, PrimitiveColumnContainer<short> column)
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4173,6 +4736,7 @@ public void Xor(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<s
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<short> column, short scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4185,6 +4749,7 @@ public void Xor(PrimitiveColumnContainer<short> column, short scalar)
                 }
             }
         }
+
         public void Xor(short scalar, PrimitiveColumnContainer<short> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4197,6 +4762,7 @@ public void Xor(short scalar, PrimitiveColumnContainer<short> column)
                 }
             }
         }
+
         public void LeftShift(PrimitiveColumnContainer<short> column, int value)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4209,6 +4775,7 @@ public void LeftShift(PrimitiveColumnContainer<short> column, int value)
                 }
             }
         }
+
         public void RightShift(PrimitiveColumnContainer<short> column, int value)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4221,8 +4788,10 @@ public void RightShift(PrimitiveColumnContainer<short> column, int value)
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4233,9 +4802,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<short> left, PrimitiveCol
                     ret[index++] = (span[i] == otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<short> column, short scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<short> column, short scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4245,9 +4817,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<short> column, short scal
                     ret[index++] = (span[i] == scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4258,9 +4833,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<short> left, Primitive
                     ret[index++] = (span[i] != otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<short> column, short scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<short> column, short scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4270,9 +4848,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<short> column, short s
                     ret[index++] = (span[i] != scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4283,9 +4864,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<short> left,
                     ret[index++] = (span[i] >= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<short> column, short scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<short> column, short scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4295,9 +4879,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<short> column
                     ret[index++] = (span[i] >= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4308,9 +4895,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<short> left, Pri
                     ret[index++] = (span[i] <= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<short> column, short scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<short> column, short scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4320,9 +4910,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<short> column, s
                     ret[index++] = (span[i] <= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4333,9 +4926,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<short> left, Primiti
                     ret[index++] = (span[i] > otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<short> column, short scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<short> column, short scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4345,9 +4941,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<short> column, short
                     ret[index++] = (span[i] > scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4358,9 +4957,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<short> left, PrimitiveC
                     ret[index++] = (span[i] < otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<short> column, short scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<short> column, short scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4370,10 +4972,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<short> column, short sc
                     ret[index++] = (span[i] < scalar);
                 }
             }
+            return ret;
         }
     }
     internal class UIntArithmetic : IPrimitiveDataFrameColumnArithmetic<uint>
     {
+
         public void Add(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4387,6 +4991,7 @@ public void Add(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<ui
                 }
             }
         }
+
         public void Add(PrimitiveColumnContainer<uint> column, uint scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4399,6 +5004,7 @@ public void Add(PrimitiveColumnContainer<uint> column, uint scalar)
                 }
             }
         }
+
         public void Add(uint scalar, PrimitiveColumnContainer<uint> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4411,6 +5017,7 @@ public void Add(uint scalar, PrimitiveColumnContainer<uint> column)
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4424,6 +5031,7 @@ public void Subtract(PrimitiveColumnContainer<uint> left, PrimitiveColumnContain
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<uint> column, uint scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4436,6 +5044,7 @@ public void Subtract(PrimitiveColumnContainer<uint> column, uint scalar)
                 }
             }
         }
+
         public void Subtract(uint scalar, PrimitiveColumnContainer<uint> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4448,6 +5057,7 @@ public void Subtract(uint scalar, PrimitiveColumnContainer<uint> column)
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4461,6 +5071,7 @@ public void Multiply(PrimitiveColumnContainer<uint> left, PrimitiveColumnContain
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<uint> column, uint scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4473,6 +5084,7 @@ public void Multiply(PrimitiveColumnContainer<uint> column, uint scalar)
                 }
             }
         }
+
         public void Multiply(uint scalar, PrimitiveColumnContainer<uint> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4485,6 +5097,7 @@ public void Multiply(uint scalar, PrimitiveColumnContainer<uint> column)
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4498,6 +5111,7 @@ public void Divide(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<uint> column, uint scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4510,6 +5124,7 @@ public void Divide(PrimitiveColumnContainer<uint> column, uint scalar)
                 }
             }
         }
+
         public void Divide(uint scalar, PrimitiveColumnContainer<uint> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4522,6 +5137,7 @@ public void Divide(uint scalar, PrimitiveColumnContainer<uint> column)
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4535,6 +5151,7 @@ public void Modulo(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<uint> column, uint scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4547,6 +5164,7 @@ public void Modulo(PrimitiveColumnContainer<uint> column, uint scalar)
                 }
             }
         }
+
         public void Modulo(uint scalar, PrimitiveColumnContainer<uint> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4559,6 +5177,7 @@ public void Modulo(uint scalar, PrimitiveColumnContainer<uint> column)
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4572,6 +5191,7 @@ public void And(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<ui
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<uint> column, uint scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4584,6 +5204,7 @@ public void And(PrimitiveColumnContainer<uint> column, uint scalar)
                 }
             }
         }
+
         public void And(uint scalar, PrimitiveColumnContainer<uint> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4596,6 +5217,7 @@ public void And(uint scalar, PrimitiveColumnContainer<uint> column)
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4609,6 +5231,7 @@ public void Or(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uin
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<uint> column, uint scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4621,6 +5244,7 @@ public void Or(PrimitiveColumnContainer<uint> column, uint scalar)
                 }
             }
         }
+
         public void Or(uint scalar, PrimitiveColumnContainer<uint> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4633,6 +5257,7 @@ public void Or(uint scalar, PrimitiveColumnContainer<uint> column)
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4646,6 +5271,7 @@ public void Xor(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<ui
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<uint> column, uint scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4658,6 +5284,7 @@ public void Xor(PrimitiveColumnContainer<uint> column, uint scalar)
                 }
             }
         }
+
         public void Xor(uint scalar, PrimitiveColumnContainer<uint> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4670,6 +5297,7 @@ public void Xor(uint scalar, PrimitiveColumnContainer<uint> column)
                 }
             }
         }
+
         public void LeftShift(PrimitiveColumnContainer<uint> column, int value)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4682,6 +5310,7 @@ public void LeftShift(PrimitiveColumnContainer<uint> column, int value)
                 }
             }
         }
+
         public void RightShift(PrimitiveColumnContainer<uint> column, int value)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4694,8 +5323,10 @@ public void RightShift(PrimitiveColumnContainer<uint> column, int value)
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4706,9 +5337,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<uint> left, PrimitiveColu
                     ret[index++] = (span[i] == otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<uint> column, uint scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<uint> column, uint scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4718,9 +5352,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<uint> column, uint scalar
                     ret[index++] = (span[i] == scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4731,9 +5368,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<uint> left, PrimitiveC
                     ret[index++] = (span[i] != otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<uint> column, uint scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<uint> column, uint scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4743,9 +5383,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<uint> column, uint sca
                     ret[index++] = (span[i] != scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4756,9 +5399,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<uint> left, P
                     ret[index++] = (span[i] >= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<uint> column, uint scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<uint> column, uint scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4768,9 +5414,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<uint> column,
                     ret[index++] = (span[i] >= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4781,9 +5430,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<uint> left, Prim
                     ret[index++] = (span[i] <= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<uint> column, uint scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<uint> column, uint scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4793,9 +5445,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<uint> column, ui
                     ret[index++] = (span[i] <= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4806,9 +5461,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<uint> left, Primitiv
                     ret[index++] = (span[i] > otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<uint> column, uint scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<uint> column, uint scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4818,9 +5476,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<uint> column, uint s
                     ret[index++] = (span[i] > scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4831,9 +5492,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<uint> left, PrimitiveCo
                     ret[index++] = (span[i] < otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<uint> column, uint scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<uint> column, uint scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4843,10 +5507,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<uint> column, uint scal
                     ret[index++] = (span[i] < scalar);
                 }
             }
+            return ret;
         }
     }
     internal class ULongArithmetic : IPrimitiveDataFrameColumnArithmetic<ulong>
     {
+
         public void Add(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4860,6 +5526,7 @@ public void Add(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<u
                 }
             }
         }
+
         public void Add(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4872,6 +5539,7 @@ public void Add(PrimitiveColumnContainer<ulong> column, ulong scalar)
                 }
             }
         }
+
         public void Add(ulong scalar, PrimitiveColumnContainer<ulong> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4884,6 +5552,7 @@ public void Add(ulong scalar, PrimitiveColumnContainer<ulong> column)
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4897,6 +5566,7 @@ public void Subtract(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContai
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4909,6 +5579,7 @@ public void Subtract(PrimitiveColumnContainer<ulong> column, ulong scalar)
                 }
             }
         }
+
         public void Subtract(ulong scalar, PrimitiveColumnContainer<ulong> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4921,6 +5592,7 @@ public void Subtract(ulong scalar, PrimitiveColumnContainer<ulong> column)
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4934,6 +5606,7 @@ public void Multiply(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContai
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4946,6 +5619,7 @@ public void Multiply(PrimitiveColumnContainer<ulong> column, ulong scalar)
                 }
             }
         }
+
         public void Multiply(ulong scalar, PrimitiveColumnContainer<ulong> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4958,6 +5632,7 @@ public void Multiply(ulong scalar, PrimitiveColumnContainer<ulong> column)
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -4971,6 +5646,7 @@ public void Divide(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContaine
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4983,6 +5659,7 @@ public void Divide(PrimitiveColumnContainer<ulong> column, ulong scalar)
                 }
             }
         }
+
         public void Divide(ulong scalar, PrimitiveColumnContainer<ulong> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -4995,6 +5672,7 @@ public void Divide(ulong scalar, PrimitiveColumnContainer<ulong> column)
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5008,6 +5686,7 @@ public void Modulo(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContaine
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5020,6 +5699,7 @@ public void Modulo(PrimitiveColumnContainer<ulong> column, ulong scalar)
                 }
             }
         }
+
         public void Modulo(ulong scalar, PrimitiveColumnContainer<ulong> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5032,6 +5712,7 @@ public void Modulo(ulong scalar, PrimitiveColumnContainer<ulong> column)
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5045,6 +5726,7 @@ public void And(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<u
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5057,6 +5739,7 @@ public void And(PrimitiveColumnContainer<ulong> column, ulong scalar)
                 }
             }
         }
+
         public void And(ulong scalar, PrimitiveColumnContainer<ulong> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5069,6 +5752,7 @@ public void And(ulong scalar, PrimitiveColumnContainer<ulong> column)
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5082,6 +5766,7 @@ public void Or(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ul
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5094,6 +5779,7 @@ public void Or(PrimitiveColumnContainer<ulong> column, ulong scalar)
                 }
             }
         }
+
         public void Or(ulong scalar, PrimitiveColumnContainer<ulong> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5106,6 +5792,7 @@ public void Or(ulong scalar, PrimitiveColumnContainer<ulong> column)
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5119,6 +5806,7 @@ public void Xor(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<u
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5131,6 +5819,7 @@ public void Xor(PrimitiveColumnContainer<ulong> column, ulong scalar)
                 }
             }
         }
+
         public void Xor(ulong scalar, PrimitiveColumnContainer<ulong> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5143,6 +5832,7 @@ public void Xor(ulong scalar, PrimitiveColumnContainer<ulong> column)
                 }
             }
         }
+
         public void LeftShift(PrimitiveColumnContainer<ulong> column, int value)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5155,6 +5845,7 @@ public void LeftShift(PrimitiveColumnContainer<ulong> column, int value)
                 }
             }
         }
+
         public void RightShift(PrimitiveColumnContainer<ulong> column, int value)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5167,8 +5858,10 @@ public void RightShift(PrimitiveColumnContainer<ulong> column, int value)
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5179,9 +5872,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<ulong> left, PrimitiveCol
                     ret[index++] = (span[i] == otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<ulong> column, ulong scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5191,9 +5887,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<ulong> column, ulong scal
                     ret[index++] = (span[i] == scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5204,9 +5903,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<ulong> left, Primitive
                     ret[index++] = (span[i] != otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<ulong> column, ulong scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5216,9 +5918,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<ulong> column, ulong s
                     ret[index++] = (span[i] != scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5229,9 +5934,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ulong> left,
                     ret[index++] = (span[i] >= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ulong> column, ulong scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5241,9 +5949,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ulong> column
                     ret[index++] = (span[i] >= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5254,9 +5965,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ulong> left, Pri
                     ret[index++] = (span[i] <= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ulong> column, ulong scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5266,9 +5980,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ulong> column, u
                     ret[index++] = (span[i] <= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5279,9 +5996,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<ulong> left, Primiti
                     ret[index++] = (span[i] > otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<ulong> column, ulong scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5291,9 +6011,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<ulong> column, ulong
                     ret[index++] = (span[i] > scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5304,9 +6027,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<ulong> left, PrimitiveC
                     ret[index++] = (span[i] < otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<ulong> column, ulong scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5316,10 +6042,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<ulong> column, ulong sc
                     ret[index++] = (span[i] < scalar);
                 }
             }
+            return ret;
         }
     }
     internal class UShortArithmetic : IPrimitiveDataFrameColumnArithmetic<ushort>
     {
+
         public void Add(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5333,6 +6061,7 @@ public void Add(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<
                 }
             }
         }
+
         public void Add(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5345,6 +6074,7 @@ public void Add(PrimitiveColumnContainer<ushort> column, ushort scalar)
                 }
             }
         }
+
         public void Add(ushort scalar, PrimitiveColumnContainer<ushort> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5357,6 +6087,7 @@ public void Add(ushort scalar, PrimitiveColumnContainer<ushort> column)
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5370,6 +6101,7 @@ public void Subtract(PrimitiveColumnContainer<ushort> left, PrimitiveColumnConta
                 }
             }
         }
+
         public void Subtract(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5382,6 +6114,7 @@ public void Subtract(PrimitiveColumnContainer<ushort> column, ushort scalar)
                 }
             }
         }
+
         public void Subtract(ushort scalar, PrimitiveColumnContainer<ushort> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5394,6 +6127,7 @@ public void Subtract(ushort scalar, PrimitiveColumnContainer<ushort> column)
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5407,6 +6141,7 @@ public void Multiply(PrimitiveColumnContainer<ushort> left, PrimitiveColumnConta
                 }
             }
         }
+
         public void Multiply(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5419,6 +6154,7 @@ public void Multiply(PrimitiveColumnContainer<ushort> column, ushort scalar)
                 }
             }
         }
+
         public void Multiply(ushort scalar, PrimitiveColumnContainer<ushort> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5431,6 +6167,7 @@ public void Multiply(ushort scalar, PrimitiveColumnContainer<ushort> column)
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5444,6 +6181,7 @@ public void Divide(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContain
                 }
             }
         }
+
         public void Divide(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5456,6 +6194,7 @@ public void Divide(PrimitiveColumnContainer<ushort> column, ushort scalar)
                 }
             }
         }
+
         public void Divide(ushort scalar, PrimitiveColumnContainer<ushort> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5468,6 +6207,7 @@ public void Divide(ushort scalar, PrimitiveColumnContainer<ushort> column)
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5481,6 +6221,7 @@ public void Modulo(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContain
                 }
             }
         }
+
         public void Modulo(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5493,6 +6234,7 @@ public void Modulo(PrimitiveColumnContainer<ushort> column, ushort scalar)
                 }
             }
         }
+
         public void Modulo(ushort scalar, PrimitiveColumnContainer<ushort> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5505,6 +6247,7 @@ public void Modulo(ushort scalar, PrimitiveColumnContainer<ushort> column)
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5518,6 +6261,7 @@ public void And(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<
                 }
             }
         }
+
         public void And(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5530,6 +6274,7 @@ public void And(PrimitiveColumnContainer<ushort> column, ushort scalar)
                 }
             }
         }
+
         public void And(ushort scalar, PrimitiveColumnContainer<ushort> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5542,6 +6287,7 @@ public void And(ushort scalar, PrimitiveColumnContainer<ushort> column)
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5555,6 +6301,7 @@ public void Or(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<u
                 }
             }
         }
+
         public void Or(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5567,6 +6314,7 @@ public void Or(PrimitiveColumnContainer<ushort> column, ushort scalar)
                 }
             }
         }
+
         public void Or(ushort scalar, PrimitiveColumnContainer<ushort> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5579,6 +6327,7 @@ public void Or(ushort scalar, PrimitiveColumnContainer<ushort> column)
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
             for (int b = 0; b < left.Buffers.Count; b++)
@@ -5592,6 +6341,7 @@ public void Xor(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<
                 }
             }
         }
+
         public void Xor(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5604,6 +6354,7 @@ public void Xor(PrimitiveColumnContainer<ushort> column, ushort scalar)
                 }
             }
         }
+
         public void Xor(ushort scalar, PrimitiveColumnContainer<ushort> column)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5616,6 +6367,7 @@ public void Xor(ushort scalar, PrimitiveColumnContainer<ushort> column)
                 }
             }
         }
+
         public void LeftShift(PrimitiveColumnContainer<ushort> column, int value)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5628,6 +6380,7 @@ public void LeftShift(PrimitiveColumnContainer<ushort> column, int value)
                 }
             }
         }
+
         public void RightShift(PrimitiveColumnContainer<ushort> column, int value)
         {
             for (int b = 0; b < column.Buffers.Count; b++)
@@ -5640,8 +6393,10 @@ public void RightShift(PrimitiveColumnContainer<ushort> column, int value)
                 }
             }
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5652,9 +6407,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<ushort> left, PrimitiveCo
                     ret[index++] = (span[i] == otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<ushort> column, ushort scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5664,9 +6422,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<ushort> column, ushort sc
                     ret[index++] = (span[i] == scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5677,9 +6438,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<ushort> left, Primitiv
                     ret[index++] = (span[i] != otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<ushort> column, ushort scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5689,9 +6453,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<ushort> column, ushort
                     ret[index++] = (span[i] != scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5702,9 +6469,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ushort> left,
                     ret[index++] = (span[i] >= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ushort> column, ushort scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5714,9 +6484,12 @@ public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ushort> colum
                     ret[index++] = (span[i] >= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5727,9 +6500,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ushort> left, Pr
                     ret[index++] = (span[i] <= otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ushort> column, ushort scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5739,9 +6515,12 @@ public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ushort> column,
                     ret[index++] = (span[i] <= scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5752,9 +6531,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<ushort> left, Primit
                     ret[index++] = (span[i] > otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<ushort> column, ushort scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5764,9 +6546,12 @@ public void ElementwiseGreaterThan(PrimitiveColumnContainer<ushort> column, usho
                     ret[index++] = (span[i] > scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5777,9 +6562,12 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<ushort> left, Primitive
                     ret[index++] = (span[i] < otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<ushort> column, ushort scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5789,116 +6577,145 @@ public void ElementwiseLessThan(PrimitiveColumnContainer<ushort> column, ushort
                     ret[index++] = (span[i] < scalar);
                 }
             }
+            return ret;
         }
     }
     internal class DateTimeArithmetic : IPrimitiveDataFrameColumnArithmetic<DateTime>
     {
+
         public void Add(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
             throw new NotSupportedException();
         }
+
         public void Add(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
             throw new NotSupportedException();
         }
+
         public void Add(DateTime scalar, PrimitiveColumnContainer<DateTime> column)
         {
             throw new NotSupportedException();
         }
+
         public void Subtract(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
             throw new NotSupportedException();
         }
+
         public void Subtract(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
             throw new NotSupportedException();
         }
+
         public void Subtract(DateTime scalar, PrimitiveColumnContainer<DateTime> column)
         {
             throw new NotSupportedException();
         }
+
         public void Multiply(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
             throw new NotSupportedException();
         }
+
         public void Multiply(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
             throw new NotSupportedException();
         }
+
         public void Multiply(DateTime scalar, PrimitiveColumnContainer<DateTime> column)
         {
             throw new NotSupportedException();
         }
+
         public void Divide(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
             throw new NotSupportedException();
         }
+
         public void Divide(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
             throw new NotSupportedException();
         }
+
         public void Divide(DateTime scalar, PrimitiveColumnContainer<DateTime> column)
         {
             throw new NotSupportedException();
         }
+
         public void Modulo(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
             throw new NotSupportedException();
         }
+
         public void Modulo(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
             throw new NotSupportedException();
         }
+
         public void Modulo(DateTime scalar, PrimitiveColumnContainer<DateTime> column)
         {
             throw new NotSupportedException();
         }
+
         public void And(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
             throw new NotSupportedException();
         }
+
         public void And(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
             throw new NotSupportedException();
         }
+
         public void And(DateTime scalar, PrimitiveColumnContainer<DateTime> column)
         {
             throw new NotSupportedException();
         }
+
         public void Or(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
             throw new NotSupportedException();
         }
+
         public void Or(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
             throw new NotSupportedException();
         }
+
         public void Or(DateTime scalar, PrimitiveColumnContainer<DateTime> column)
         {
             throw new NotSupportedException();
         }
+
         public void Xor(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
             throw new NotSupportedException();
         }
+
         public void Xor(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
             throw new NotSupportedException();
         }
+
         public void Xor(DateTime scalar, PrimitiveColumnContainer<DateTime> column)
         {
             throw new NotSupportedException();
         }
+
         public void LeftShift(PrimitiveColumnContainer<DateTime> column, int value)
         {
             throw new NotSupportedException();
         }
+
         public void RightShift(PrimitiveColumnContainer<DateTime> column, int value)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5909,9 +6726,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<DateTime> left, Primitive
                     ret[index++] = (span[i] == otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseEquals(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5921,9 +6741,12 @@ public void ElementwiseEquals(PrimitiveColumnContainer<DateTime> column, DateTim
                     ret[index++] = (span[i] == scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5934,9 +6757,12 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<DateTime> left, Primit
                     ret[index++] = (span[i] != otherSpan[i]);
                 }
             }
+            return ret;
         }
-        public void ElementwiseNotEquals(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5946,36 +6772,45 @@ public void ElementwiseNotEquals(PrimitiveColumnContainer<DateTime> column, Date
                     ret[index++] = (span[i] != scalar);
                 }
             }
+            return ret;
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseLessThanOrEqual(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseGreaterThan(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
             throw new NotSupportedException();
         }
-        public void ElementwiseLessThan(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
+
+        public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
             throw new NotSupportedException();
         }
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt
index 790eb2bfca..d158295b1a 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt
@@ -21,7 +21,11 @@ namespace Microsoft.Data.Analysis
         where T : unmanaged
     {
 <# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (method.MethodType == MethodType.Comparison || method.MethodType == MethodType.ComparisonScalar) { #>
+        PrimitiveColumnContainer<bool> <#=method.MethodName#>(<#=method.GetMethodArguments("PrimitiveColumnContainer", "T")#>);
+<#} else {#>
         void <#=method.MethodName#>(<#=method.GetMethodArguments("PrimitiveColumnContainer", "T")#>);
+<# } #>
 <# if (method.MethodType == MethodType.BinaryScalar) { #>
         <#= method.GetInvertedMethodSignatureForBinaryScalarsOps("PrimitiveColumnContainer", "T")#>;
 <# } #>
@@ -48,17 +52,24 @@ namespace Microsoft.Data.Analysis
             throw new NotSupportedException();
         }
     }
-
 <# foreach (TypeConfiguration type in typeConfiguration) { #>
     internal class <#=type.ClassPrefix#>Arithmetic : IPrimitiveDataFrameColumnArithmetic<<#=type.TypeName#>>
     {
 <# foreach (MethodConfiguration method in methodConfiguration) { #>
+<# if (method.MethodType == MethodType.Comparison || method.MethodType == MethodType.ComparisonScalar) { #>
+
+        public PrimitiveColumnContainer<bool> <#=method.MethodName#>(<#=method.GetMethodArguments("PrimitiveColumnContainer", type.TypeName)#>)
+        {
+<#} else {#>
+
         public void <#=method.MethodName#>(<#=method.GetMethodArguments("PrimitiveColumnContainer", type.TypeName)#>)
         {
+<# } #>
 <# if ((method.IsNumeric && !type.SupportsNumeric) || (method.IsBitwise && !type.SupportsBitwise) || (type.UnsupportedMethods.Contains(method.MethodName))) { #>
             throw new NotSupportedException();
 <# } else if (method.Operator != null) { #>
 <# if (method.MethodType == MethodType.Comparison || method.MethodType == MethodType.ComparisonScalar) { #>
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
             long index = 0;
 <# } #>
             for (int b = 0; b < <#= method.Op1Name #>.Buffers.Count; b++)
@@ -90,9 +101,13 @@ namespace Microsoft.Data.Analysis
 <# } #>
                 }
             }
+<# if (method.MethodType == MethodType.Comparison || method.MethodType == MethodType.ComparisonScalar) { #>
+            return ret;
+<# } #>
 <# } #>
         }
 <# if (method.MethodType == MethodType.BinaryScalar) { #>
+
         public <#= method.GetInvertedMethodSignatureForBinaryScalarsOps("PrimitiveColumnContainer", type.TypeName) #>
         {
 <# if ((method.IsNumeric && !type.SupportsNumeric) || (method.IsBitwise && !type.SupportsBitwise) || (type.UnsupportedMethods.Contains(method.MethodName))) { #>

From cbbf282e4fea73a1f6ced3c32a8d7fd8a2a5d07e Mon Sep 17 00:00:00 2001
From: Aleksei Smirnov <tlalok@inbox.ru>
Date: Thu, 13 Jul 2023 18:02:24 +0300
Subject: [PATCH 3/6] Change DataFrameColumn Operations

---
 .../ColumnArithmeticTemplate.ttinclude        |   1 -
 .../DataFrameColumn.BinaryOperations.cs       |   2 +-
 .../DataFrameColumn.BinaryOperations.tt       |   2 +-
 ...BinaryOperationImplementations.Exploded.cs | 156 +++++-----
 ...BinaryOperationImplementations.Exploded.tt |   2 +-
 ...imitiveDataFrameColumn.BinaryOperations.cs | 272 +++++-------------
 ...imitiveDataFrameColumn.BinaryOperations.tt |  67 ++---
 7 files changed, 167 insertions(+), 335 deletions(-)

diff --git a/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude b/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude
index c9a89655fd..7109530e3b 100644
--- a/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude
+++ b/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude
@@ -426,7 +426,6 @@
                 case MethodType.Unary:
                 case MethodType.UnaryInPlace:
                     throw new ArgumentException();
-                    return $"{dataFrameType}<{genericType}> {Op1Name}";
                 case MethodType.BinaryScalar:
                     return $"{genericType} {Op2Name}";
                 case MethodType.ComparisonScalar:
diff --git a/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.cs b/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.cs
index 1c340575db..5ec875dbd4 100644
--- a/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.cs
+++ b/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.cs
@@ -332,4 +332,4 @@ public virtual PrimitiveDataFrameColumn<bool> ElementwiseIsNotNull()
             throw new NotImplementedException();
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt b/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt
index dc0c4fa988..7ffed4f62a 100644
--- a/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt
+++ b/src/Microsoft.Data.Analysis/DataFrameColumn.BinaryOperations.tt
@@ -94,4 +94,4 @@ namespace Microsoft.Data.Analysis
             throw new NotImplementedException();
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs
index 95e443545e..ac8035f0ba 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.cs
@@ -1275,7 +1275,7 @@ public partial class BooleanDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(bool value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
 
@@ -1283,7 +1283,7 @@ public partial class ByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(byte value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
 
@@ -1291,7 +1291,7 @@ public partial class DecimalDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(decimal value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
 
@@ -1299,7 +1299,7 @@ public partial class DoubleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(double value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
 
@@ -1307,7 +1307,7 @@ public partial class SingleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(float value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
 
@@ -1315,7 +1315,7 @@ public partial class Int32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(int value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
 
@@ -1323,7 +1323,7 @@ public partial class Int64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(long value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
 
@@ -1331,7 +1331,7 @@ public partial class SByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(sbyte value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
 
@@ -1339,7 +1339,7 @@ public partial class Int16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(short value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
 
@@ -1347,7 +1347,7 @@ public partial class UInt32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(uint value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
 
@@ -1355,7 +1355,7 @@ public partial class UInt64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(ulong value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
 
@@ -1363,7 +1363,7 @@ public partial class UInt16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(ushort value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
 
@@ -1371,7 +1371,7 @@ public partial class DateTimeDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseEqualsImplementation(DateTime value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseEquals(value));
         }
     }
 
@@ -1483,7 +1483,7 @@ public partial class BooleanDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(bool value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
 
@@ -1491,7 +1491,7 @@ public partial class ByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(byte value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
 
@@ -1499,7 +1499,7 @@ public partial class DecimalDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(decimal value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
 
@@ -1507,7 +1507,7 @@ public partial class DoubleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(double value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
 
@@ -1515,7 +1515,7 @@ public partial class SingleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(float value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
 
@@ -1523,7 +1523,7 @@ public partial class Int32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(int value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
 
@@ -1531,7 +1531,7 @@ public partial class Int64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(long value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
 
@@ -1539,7 +1539,7 @@ public partial class SByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(sbyte value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
 
@@ -1547,7 +1547,7 @@ public partial class Int16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(short value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
 
@@ -1555,7 +1555,7 @@ public partial class UInt32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(uint value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
 
@@ -1563,7 +1563,7 @@ public partial class UInt64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(ulong value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
 
@@ -1571,7 +1571,7 @@ public partial class UInt16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(ushort value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
 
@@ -1579,7 +1579,7 @@ public partial class DateTimeDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseNotEqualsImplementation(DateTime value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseNotEquals(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseNotEquals(value));
         }
     }
 
@@ -1691,7 +1691,7 @@ public partial class BooleanDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(bool value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
 
@@ -1699,7 +1699,7 @@ public partial class ByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(byte value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
 
@@ -1707,7 +1707,7 @@ public partial class DecimalDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(decimal value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
 
@@ -1715,7 +1715,7 @@ public partial class DoubleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(double value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
 
@@ -1723,7 +1723,7 @@ public partial class SingleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(float value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
 
@@ -1731,7 +1731,7 @@ public partial class Int32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(int value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
 
@@ -1739,7 +1739,7 @@ public partial class Int64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(long value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
 
@@ -1747,7 +1747,7 @@ public partial class SByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(sbyte value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
 
@@ -1755,7 +1755,7 @@ public partial class Int16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(short value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
 
@@ -1763,7 +1763,7 @@ public partial class UInt32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(uint value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
 
@@ -1771,7 +1771,7 @@ public partial class UInt64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(ulong value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
 
@@ -1779,7 +1779,7 @@ public partial class UInt16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(ushort value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
 
@@ -1787,7 +1787,7 @@ public partial class DateTimeDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanOrEqualImplementation(DateTime value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThanOrEqual(value));
         }
     }
 
@@ -1899,7 +1899,7 @@ public partial class BooleanDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(bool value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
 
@@ -1907,7 +1907,7 @@ public partial class ByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(byte value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
 
@@ -1915,7 +1915,7 @@ public partial class DecimalDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(decimal value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
 
@@ -1923,7 +1923,7 @@ public partial class DoubleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(double value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
 
@@ -1931,7 +1931,7 @@ public partial class SingleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(float value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
 
@@ -1939,7 +1939,7 @@ public partial class Int32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(int value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
 
@@ -1947,7 +1947,7 @@ public partial class Int64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(long value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
 
@@ -1955,7 +1955,7 @@ public partial class SByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(sbyte value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
 
@@ -1963,7 +1963,7 @@ public partial class Int16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(short value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
 
@@ -1971,7 +1971,7 @@ public partial class UInt32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(uint value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
 
@@ -1979,7 +1979,7 @@ public partial class UInt64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(ulong value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
 
@@ -1987,7 +1987,7 @@ public partial class UInt16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(ushort value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
 
@@ -1995,7 +1995,7 @@ public partial class DateTimeDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanOrEqualImplementation(DateTime value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThanOrEqual(value));
         }
     }
 
@@ -2107,7 +2107,7 @@ public partial class BooleanDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(bool value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
 
@@ -2115,7 +2115,7 @@ public partial class ByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(byte value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
 
@@ -2123,7 +2123,7 @@ public partial class DecimalDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(decimal value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
 
@@ -2131,7 +2131,7 @@ public partial class DoubleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(double value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
 
@@ -2139,7 +2139,7 @@ public partial class SingleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(float value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
 
@@ -2147,7 +2147,7 @@ public partial class Int32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(int value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
 
@@ -2155,7 +2155,7 @@ public partial class Int64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(long value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
 
@@ -2163,7 +2163,7 @@ public partial class SByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(sbyte value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
 
@@ -2171,7 +2171,7 @@ public partial class Int16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(short value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
 
@@ -2179,7 +2179,7 @@ public partial class UInt32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(uint value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
 
@@ -2187,7 +2187,7 @@ public partial class UInt64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(ulong value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
 
@@ -2195,7 +2195,7 @@ public partial class UInt16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(ushort value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
 
@@ -2203,7 +2203,7 @@ public partial class DateTimeDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseGreaterThanImplementation(DateTime value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseGreaterThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseGreaterThan(value));
         }
     }
 
@@ -2315,7 +2315,7 @@ public partial class BooleanDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(bool value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
 
@@ -2323,7 +2323,7 @@ public partial class ByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(byte value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
 
@@ -2331,7 +2331,7 @@ public partial class DecimalDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(decimal value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
 
@@ -2339,7 +2339,7 @@ public partial class DoubleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(double value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
 
@@ -2347,7 +2347,7 @@ public partial class SingleDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(float value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
 
@@ -2355,7 +2355,7 @@ public partial class Int32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(int value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
 
@@ -2363,7 +2363,7 @@ public partial class Int64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(long value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
 
@@ -2371,7 +2371,7 @@ public partial class SByteDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(sbyte value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
 
@@ -2379,7 +2379,7 @@ public partial class Int16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(short value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
 
@@ -2387,7 +2387,7 @@ public partial class UInt32DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(uint value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
 
@@ -2395,7 +2395,7 @@ public partial class UInt64DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(ulong value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
 
@@ -2403,7 +2403,7 @@ public partial class UInt16DataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(ushort value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
 
@@ -2411,7 +2411,7 @@ public partial class DateTimeDataFrameColumn
     {
         internal BooleanDataFrameColumn ElementwiseLessThanImplementation(DateTime value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.ElementwiseLessThan(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.ElementwiseLessThan(value));
         }
     }
 }
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt
index b71ba41c3b..001aab32b1 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperationImplementations.Exploded.tt
@@ -201,7 +201,7 @@ void GenerateAllComparisonScalarCombinationsForMethod(string inputMethodName)
     {
         internal <#=fullReturnType#> <#=methodName#>(<#=otherColumnType#> value)
         {
-            return new BooleanDataFrameColumn (Name, ColumnContainer.<#=inputMethodName#>(value));
+            return new BooleanDataFrameColumn(Name, ColumnContainer.<#=inputMethodName#>(value));
         }
     }
 <# 
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs
index 74506e0904..461badeda3 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.cs
@@ -1862,9 +1862,7 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseEqualsImplementation<U>(Primi
                     {
                         throw new NotSupportedException();
                     }
-                    PrimitiveDataFrameColumn<bool> retboolColumn = CloneAsBooleanColumn();
-                    (this as PrimitiveDataFrameColumn<U>)._columnContainer.ElementwiseEquals(column._columnContainer, retboolColumn._columnContainer);
-                    return retboolColumn;
+                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<U>)._columnContainer.ElementwiseEquals(column._columnContainer));
                 case Type decimalType when decimalType == typeof(decimal):
                     if (typeof(U) == typeof(bool))
                     {
@@ -1874,25 +1872,19 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseEqualsImplementation<U>(Primi
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseEquals(column._columnContainer, newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(column._columnContainer));
                     }
                     else
                     {
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                         PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.ElementwiseEquals(column.CloneAsDecimalColumn()._columnContainer, newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseEquals(column.CloneAsDecimalColumn()._columnContainer));
                     }
                 case Type DateTimeType when DateTimeType == typeof(DateTime):
                     if (typeof(U) != typeof(DateTime))
                     {
                         throw new NotSupportedException();
                     }
-                    PrimitiveDataFrameColumn<bool> retDateTimeColumn = CloneAsBooleanColumn();
-                    (this as PrimitiveDataFrameColumn<U>)._columnContainer.ElementwiseEquals(column._columnContainer, retDateTimeColumn._columnContainer);
-                    return retDateTimeColumn;
+                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<U>)._columnContainer.ElementwiseEquals(column._columnContainer));
                 case Type byteType when byteType == typeof(byte):
                 case Type charType when charType == typeof(char):
                 case Type doubleType when doubleType == typeof(double):
@@ -1912,25 +1904,19 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseEqualsImplementation<U>(Primi
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseEquals(column._columnContainer, newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(column._columnContainer));
                     }
                     else
                     {
                         if (typeof(U) == typeof(decimal))
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.ElementwiseEquals((column as PrimitiveDataFrameColumn<decimal>)._columnContainer, newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseEquals((column as PrimitiveDataFrameColumn<decimal>)._columnContainer));
                         }
                         else
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.ElementwiseEquals(column.CloneAsDoubleColumn()._columnContainer, newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseEquals(column.CloneAsDoubleColumn()._columnContainer));
                         }
                     }
                 default:
@@ -1947,9 +1933,7 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseEqualsImplementation<U>(U val
                     {
                         throw new NotSupportedException();
                     }
-                    PrimitiveDataFrameColumn<bool> retboolColumn = CloneAsBooleanColumn();
-                    (this as PrimitiveDataFrameColumn<bool>)._columnContainer.ElementwiseEquals(Unsafe.As<U, bool>(ref value), retboolColumn._columnContainer);
-                    return retboolColumn;
+                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<bool>)._columnContainer.ElementwiseEquals(Unsafe.As<U, bool>(ref value)));
                 case Type decimalType when decimalType == typeof(decimal):
                     if (typeof(U) == typeof(bool))
                     {
@@ -1959,25 +1943,19 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseEqualsImplementation<U>(U val
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseEquals(Unsafe.As<U, T>(ref value), newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(Unsafe.As<U, T>(ref value)));
                     }
                     else
                     {
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                         PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.ElementwiseEquals(DecimalConverter<U>.Instance.GetDecimal(value), newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseEquals(DecimalConverter<U>.Instance.GetDecimal(value)));
                     }
                 case Type DateTimeType when DateTimeType == typeof(DateTime):
                     if (typeof(U) != typeof(DateTime))
                     {
                         throw new NotSupportedException();
                     }
-                    PrimitiveDataFrameColumn<bool> retDateTimeColumn = CloneAsBooleanColumn();
-                    (this as PrimitiveDataFrameColumn<bool>)._columnContainer.ElementwiseEquals(Unsafe.As<U, bool>(ref value), retDateTimeColumn._columnContainer);
-                    return retDateTimeColumn;
+                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<bool>)._columnContainer.ElementwiseEquals(Unsafe.As<U, bool>(ref value)));
                 case Type byteType when byteType == typeof(byte):
                 case Type charType when charType == typeof(char):
                 case Type doubleType when doubleType == typeof(double):
@@ -1997,25 +1975,19 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseEqualsImplementation<U>(U val
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseEquals(Unsafe.As<U, T>(ref value), newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseEquals(Unsafe.As<U, T>(ref value)));
                     }
                     else
                     {
                         if (typeof(U) == typeof(decimal))
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.ElementwiseEquals(DecimalConverter<U>.Instance.GetDecimal(value), newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseEquals(DecimalConverter<U>.Instance.GetDecimal(value)));
                         }
                         else
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.ElementwiseEquals(DoubleConverter<U>.Instance.GetDouble(value), newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseEquals(DoubleConverter<U>.Instance.GetDouble(value)));
                         }
                     }
                 default:
@@ -2037,9 +2009,7 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseNotEqualsImplementation<U>(Pr
                     {
                         throw new NotSupportedException();
                     }
-                    PrimitiveDataFrameColumn<bool> retboolColumn = CloneAsBooleanColumn();
-                    (this as PrimitiveDataFrameColumn<U>)._columnContainer.ElementwiseNotEquals(column._columnContainer, retboolColumn._columnContainer);
-                    return retboolColumn;
+                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<U>)._columnContainer.ElementwiseNotEquals(column._columnContainer));
                 case Type decimalType when decimalType == typeof(decimal):
                     if (typeof(U) == typeof(bool))
                     {
@@ -2049,25 +2019,19 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseNotEqualsImplementation<U>(Pr
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseNotEquals(column._columnContainer, newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(column._columnContainer));
                     }
                     else
                     {
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                         PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.ElementwiseNotEquals(column.CloneAsDecimalColumn()._columnContainer, newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseNotEquals(column.CloneAsDecimalColumn()._columnContainer));
                     }
                 case Type DateTimeType when DateTimeType == typeof(DateTime):
                     if (typeof(U) != typeof(DateTime))
                     {
                         throw new NotSupportedException();
                     }
-                    PrimitiveDataFrameColumn<bool> retDateTimeColumn = CloneAsBooleanColumn();
-                    (this as PrimitiveDataFrameColumn<U>)._columnContainer.ElementwiseNotEquals(column._columnContainer, retDateTimeColumn._columnContainer);
-                    return retDateTimeColumn;
+                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<U>)._columnContainer.ElementwiseNotEquals(column._columnContainer));
                 case Type byteType when byteType == typeof(byte):
                 case Type charType when charType == typeof(char):
                 case Type doubleType when doubleType == typeof(double):
@@ -2087,25 +2051,19 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseNotEqualsImplementation<U>(Pr
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseNotEquals(column._columnContainer, newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(column._columnContainer));
                     }
                     else
                     {
                         if (typeof(U) == typeof(decimal))
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.ElementwiseNotEquals((column as PrimitiveDataFrameColumn<decimal>)._columnContainer, newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseNotEquals((column as PrimitiveDataFrameColumn<decimal>)._columnContainer));
                         }
                         else
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.ElementwiseNotEquals(column.CloneAsDoubleColumn()._columnContainer, newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseNotEquals(column.CloneAsDoubleColumn()._columnContainer));
                         }
                     }
                 default:
@@ -2122,9 +2080,7 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseNotEqualsImplementation<U>(U
                     {
                         throw new NotSupportedException();
                     }
-                    PrimitiveDataFrameColumn<bool> retboolColumn = CloneAsBooleanColumn();
-                    (this as PrimitiveDataFrameColumn<bool>)._columnContainer.ElementwiseNotEquals(Unsafe.As<U, bool>(ref value), retboolColumn._columnContainer);
-                    return retboolColumn;
+                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<bool>)._columnContainer.ElementwiseNotEquals(Unsafe.As<U, bool>(ref value)));
                 case Type decimalType when decimalType == typeof(decimal):
                     if (typeof(U) == typeof(bool))
                     {
@@ -2134,25 +2090,19 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseNotEqualsImplementation<U>(U
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseNotEquals(Unsafe.As<U, T>(ref value), newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(Unsafe.As<U, T>(ref value)));
                     }
                     else
                     {
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                         PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.ElementwiseNotEquals(DecimalConverter<U>.Instance.GetDecimal(value), newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseNotEquals(DecimalConverter<U>.Instance.GetDecimal(value)));
                     }
                 case Type DateTimeType when DateTimeType == typeof(DateTime):
                     if (typeof(U) != typeof(DateTime))
                     {
                         throw new NotSupportedException();
                     }
-                    PrimitiveDataFrameColumn<bool> retDateTimeColumn = CloneAsBooleanColumn();
-                    (this as PrimitiveDataFrameColumn<bool>)._columnContainer.ElementwiseNotEquals(Unsafe.As<U, bool>(ref value), retDateTimeColumn._columnContainer);
-                    return retDateTimeColumn;
+                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<bool>)._columnContainer.ElementwiseNotEquals(Unsafe.As<U, bool>(ref value)));
                 case Type byteType when byteType == typeof(byte):
                 case Type charType when charType == typeof(char):
                 case Type doubleType when doubleType == typeof(double):
@@ -2172,25 +2122,19 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseNotEqualsImplementation<U>(U
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseNotEquals(Unsafe.As<U, T>(ref value), newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseNotEquals(Unsafe.As<U, T>(ref value)));
                     }
                     else
                     {
                         if (typeof(U) == typeof(decimal))
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.ElementwiseNotEquals(DecimalConverter<U>.Instance.GetDecimal(value), newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseNotEquals(DecimalConverter<U>.Instance.GetDecimal(value)));
                         }
                         else
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.ElementwiseNotEquals(DoubleConverter<U>.Instance.GetDouble(value), newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseNotEquals(DoubleConverter<U>.Instance.GetDouble(value)));
                         }
                     }
                 default:
@@ -2218,16 +2162,12 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseGreaterThanOrEqualImplementat
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(column._columnContainer, newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(column._columnContainer));
                     }
                     else
                     {
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                         PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(column.CloneAsDecimalColumn()._columnContainer, newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(column.CloneAsDecimalColumn()._columnContainer));
                     }
                 case Type DateTimeType when DateTimeType == typeof(DateTime):
                     throw new NotSupportedException();
@@ -2250,25 +2190,19 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseGreaterThanOrEqualImplementat
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(column._columnContainer, newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(column._columnContainer));
                     }
                     else
                     {
                         if (typeof(U) == typeof(decimal))
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual((column as PrimitiveDataFrameColumn<decimal>)._columnContainer, newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual((column as PrimitiveDataFrameColumn<decimal>)._columnContainer));
                         }
                         else
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.ElementwiseGreaterThanOrEqual(column.CloneAsDoubleColumn()._columnContainer, newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThanOrEqual(column.CloneAsDoubleColumn()._columnContainer));
                         }
                     }
                 default:
@@ -2291,16 +2225,12 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseGreaterThanOrEqualImplementat
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(Unsafe.As<U, T>(ref value), newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(Unsafe.As<U, T>(ref value)));
                     }
                     else
                     {
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                         PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(DecimalConverter<U>.Instance.GetDecimal(value), newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(DecimalConverter<U>.Instance.GetDecimal(value)));
                     }
                 case Type DateTimeType when DateTimeType == typeof(DateTime):
                     throw new NotSupportedException();
@@ -2323,25 +2253,19 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseGreaterThanOrEqualImplementat
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(Unsafe.As<U, T>(ref value), newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThanOrEqual(Unsafe.As<U, T>(ref value)));
                     }
                     else
                     {
                         if (typeof(U) == typeof(decimal))
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(DecimalConverter<U>.Instance.GetDecimal(value), newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThanOrEqual(DecimalConverter<U>.Instance.GetDecimal(value)));
                         }
                         else
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.ElementwiseGreaterThanOrEqual(DoubleConverter<U>.Instance.GetDouble(value), newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThanOrEqual(DoubleConverter<U>.Instance.GetDouble(value)));
                         }
                     }
                 default:
@@ -2369,16 +2293,12 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseLessThanOrEqualImplementation
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(column._columnContainer, newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(column._columnContainer));
                     }
                     else
                     {
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                         PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.ElementwiseLessThanOrEqual(column.CloneAsDecimalColumn()._columnContainer, newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual(column.CloneAsDecimalColumn()._columnContainer));
                     }
                 case Type DateTimeType when DateTimeType == typeof(DateTime):
                     throw new NotSupportedException();
@@ -2401,25 +2321,19 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseLessThanOrEqualImplementation
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(column._columnContainer, newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(column._columnContainer));
                     }
                     else
                     {
                         if (typeof(U) == typeof(decimal))
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.ElementwiseLessThanOrEqual((column as PrimitiveDataFrameColumn<decimal>)._columnContainer, newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual((column as PrimitiveDataFrameColumn<decimal>)._columnContainer));
                         }
                         else
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.ElementwiseLessThanOrEqual(column.CloneAsDoubleColumn()._columnContainer, newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThanOrEqual(column.CloneAsDoubleColumn()._columnContainer));
                         }
                     }
                 default:
@@ -2442,16 +2356,12 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseLessThanOrEqualImplementation
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(Unsafe.As<U, T>(ref value), newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(Unsafe.As<U, T>(ref value)));
                     }
                     else
                     {
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                         PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.ElementwiseLessThanOrEqual(DecimalConverter<U>.Instance.GetDecimal(value), newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual(DecimalConverter<U>.Instance.GetDecimal(value)));
                     }
                 case Type DateTimeType when DateTimeType == typeof(DateTime):
                     throw new NotSupportedException();
@@ -2474,25 +2384,19 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseLessThanOrEqualImplementation
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(Unsafe.As<U, T>(ref value), newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThanOrEqual(Unsafe.As<U, T>(ref value)));
                     }
                     else
                     {
                         if (typeof(U) == typeof(decimal))
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.ElementwiseLessThanOrEqual(DecimalConverter<U>.Instance.GetDecimal(value), newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThanOrEqual(DecimalConverter<U>.Instance.GetDecimal(value)));
                         }
                         else
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.ElementwiseLessThanOrEqual(DoubleConverter<U>.Instance.GetDouble(value), newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThanOrEqual(DoubleConverter<U>.Instance.GetDouble(value)));
                         }
                     }
                 default:
@@ -2520,16 +2424,12 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseGreaterThanImplementation<U>(
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseGreaterThan(column._columnContainer, newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(column._columnContainer));
                     }
                     else
                     {
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                         PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.ElementwiseGreaterThan(column.CloneAsDecimalColumn()._columnContainer, newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan(column.CloneAsDecimalColumn()._columnContainer));
                     }
                 case Type DateTimeType when DateTimeType == typeof(DateTime):
                     throw new NotSupportedException();
@@ -2552,25 +2452,19 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseGreaterThanImplementation<U>(
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseGreaterThan(column._columnContainer, newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(column._columnContainer));
                     }
                     else
                     {
                         if (typeof(U) == typeof(decimal))
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.ElementwiseGreaterThan((column as PrimitiveDataFrameColumn<decimal>)._columnContainer, newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan((column as PrimitiveDataFrameColumn<decimal>)._columnContainer));
                         }
                         else
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.ElementwiseGreaterThan(column.CloneAsDoubleColumn()._columnContainer, newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThan(column.CloneAsDoubleColumn()._columnContainer));
                         }
                     }
                 default:
@@ -2593,16 +2487,12 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseGreaterThanImplementation<U>(
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseGreaterThan(Unsafe.As<U, T>(ref value), newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(Unsafe.As<U, T>(ref value)));
                     }
                     else
                     {
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                         PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.ElementwiseGreaterThan(DecimalConverter<U>.Instance.GetDecimal(value), newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan(DecimalConverter<U>.Instance.GetDecimal(value)));
                     }
                 case Type DateTimeType when DateTimeType == typeof(DateTime):
                     throw new NotSupportedException();
@@ -2625,25 +2515,19 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseGreaterThanImplementation<U>(
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseGreaterThan(Unsafe.As<U, T>(ref value), newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseGreaterThan(Unsafe.As<U, T>(ref value)));
                     }
                     else
                     {
                         if (typeof(U) == typeof(decimal))
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.ElementwiseGreaterThan(DecimalConverter<U>.Instance.GetDecimal(value), newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseGreaterThan(DecimalConverter<U>.Instance.GetDecimal(value)));
                         }
                         else
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.ElementwiseGreaterThan(DoubleConverter<U>.Instance.GetDouble(value), newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseGreaterThan(DoubleConverter<U>.Instance.GetDouble(value)));
                         }
                     }
                 default:
@@ -2671,16 +2555,12 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseLessThanImplementation<U>(Pri
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseLessThan(column._columnContainer, newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(column._columnContainer));
                     }
                     else
                     {
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                         PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.ElementwiseLessThan(column.CloneAsDecimalColumn()._columnContainer, newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan(column.CloneAsDecimalColumn()._columnContainer));
                     }
                 case Type DateTimeType when DateTimeType == typeof(DateTime):
                     throw new NotSupportedException();
@@ -2703,25 +2583,19 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseLessThanImplementation<U>(Pri
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseLessThan(column._columnContainer, newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(column._columnContainer));
                     }
                     else
                     {
                         if (typeof(U) == typeof(decimal))
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.ElementwiseLessThan((column as PrimitiveDataFrameColumn<decimal>)._columnContainer, newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan((column as PrimitiveDataFrameColumn<decimal>)._columnContainer));
                         }
                         else
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.ElementwiseLessThan(column.CloneAsDoubleColumn()._columnContainer, newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThan(column.CloneAsDoubleColumn()._columnContainer));
                         }
                     }
                 default:
@@ -2744,16 +2618,12 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseLessThanImplementation<U>(U v
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseLessThan(Unsafe.As<U, T>(ref value), newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(Unsafe.As<U, T>(ref value)));
                     }
                     else
                     {
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                         PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.ElementwiseLessThan(DecimalConverter<U>.Instance.GetDecimal(value), newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan(DecimalConverter<U>.Instance.GetDecimal(value)));
                     }
                 case Type DateTimeType when DateTimeType == typeof(DateTime):
                     throw new NotSupportedException();
@@ -2776,25 +2646,19 @@ internal PrimitiveDataFrameColumn<bool> ElementwiseLessThanImplementation<U>(U v
                     {
                         // No conversions
                         PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.ElementwiseLessThan(Unsafe.As<U, T>(ref value), newColumn._columnContainer);
-                        return newColumn;
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.ElementwiseLessThan(Unsafe.As<U, T>(ref value)));
                     }
                     else
                     {
                         if (typeof(U) == typeof(decimal))
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.ElementwiseLessThan(DecimalConverter<U>.Instance.GetDecimal(value), newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.ElementwiseLessThan(DecimalConverter<U>.Instance.GetDecimal(value)));
                         }
                         else
                         {
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
                             PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.ElementwiseLessThan(DoubleConverter<U>.Instance.GetDouble(value), newColumn._columnContainer);
-                            return newColumn;
+                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.ElementwiseLessThan(DoubleConverter<U>.Instance.GetDouble(value)));
                         }
                     }
                 default:
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt
index 83a6c80d49..66d04d02ec 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumn.BinaryOperations.tt
@@ -189,13 +189,10 @@ namespace Microsoft.Data.Analysis
                     {
                         throw new NotSupportedException();
                     }
-<# if (method.MethodType == MethodType.ComparisonScalar || method.MethodType == MethodType.Comparison) { #>
-                    PrimitiveDataFrameColumn<bool> ret<#=type.TypeName#>Column = CloneAsBooleanColumn();
 <# if (method.MethodType == MethodType.ComparisonScalar) { #>
-                    (this as PrimitiveDataFrameColumn<bool>)._columnContainer.<#=method.MethodName#>(Unsafe.As<U, bool>(ref value), ret<#=type.TypeName#>Column._columnContainer);
-<# } else { #>
-                    (this as PrimitiveDataFrameColumn<U>)._columnContainer.<#=method.MethodName#>(column._columnContainer, ret<#=type.TypeName#>Column._columnContainer);
-<# } #>
+                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<bool>)._columnContainer.<#=method.MethodName#>(Unsafe.As<U, bool>(ref value)));
+<# } else if (method.MethodType == MethodType.Comparison) { #>
+                    return new BooleanDataFrameColumn(Name, (this as PrimitiveDataFrameColumn<U>)._columnContainer.<#=method.MethodName#>(column._columnContainer));
 <# } else if (method.MethodType == MethodType.BinaryScalar) {#>
                     PrimitiveDataFrameColumn<U> column = this as PrimitiveDataFrameColumn<U>;
                     PrimitiveDataFrameColumn<U> ret<#=type.TypeName#>Column = <#=GenerateInPlaceStatement("column", "column.Clone()")#>;
@@ -205,7 +202,6 @@ namespace Microsoft.Data.Analysis
                     PrimitiveDataFrameColumn<U> ret<#=type.TypeName#>Column = <#=GenerateInPlaceStatement("column", "column.Clone()")#>;
                     ret<#=type.TypeName#>Column._columnContainer.<#=method.MethodName#>(column._columnContainer);
 <# } #>
-                    return ret<#=type.TypeName#>Column;
 <# } #>
 <# } else if (type.TypeName == "decimal") { #>
                 case Type <#=type.TypeName#>Type when <#=type.TypeName#>Type == typeof(<#=type.TypeName#>):
@@ -216,18 +212,12 @@ namespace Microsoft.Data.Analysis
                     if (typeof(U) == typeof(T))
                     {
                         // No conversions
-<# if (method.MethodType == MethodType.ComparisonScalar || method.MethodType == MethodType.Comparison) { #>
 <# if (method.MethodType == MethodType.ComparisonScalar) { #>
                         PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.<#=method.MethodName#>(Unsafe.As<U, T>(ref value), newColumn._columnContainer);
-                        return newColumn;
-<# } else { #>
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.<#=method.MethodName#>(Unsafe.As<U, T>(ref value)));
+<# } else if (method.MethodType == MethodType.Comparison){ #>
                         PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.<#=method.MethodName#>(column._columnContainer, newColumn._columnContainer);
-                        return newColumn;
-<# } #>
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.<#=method.MethodName#>(column._columnContainer));
 <# } else if (method.IsBitwise == true ) { #>
                         throw new NotSupportedException();
 <# } else if (method.MethodType == MethodType.BinaryScalar ) { #>
@@ -255,17 +245,12 @@ namespace Microsoft.Data.Analysis
                             throw new ArgumentException(string.Format(Strings.MismatchedColumnValueType, typeof(T)), nameof(column));
                         }
 <# } #>
-<# if (method.MethodType == MethodType.ComparisonScalar || method.MethodType == MethodType.Comparison) { #>
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
 <# if (method.MethodType == MethodType.ComparisonScalar) { #>
                         PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.<#=method.MethodName#>(DecimalConverter<U>.Instance.GetDecimal(value), newColumn._columnContainer);
-                        return newColumn;
-<# } else { #>
+                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.<#=method.MethodName#>(DecimalConverter<U>.Instance.GetDecimal(value)));
+<# } else if (method.MethodType == MethodType.Comparison){ #>
                         PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                        decimalColumn._columnContainer.<#=method.MethodName#>(column.CloneAsDecimalColumn()._columnContainer, newColumn._columnContainer);
-                        return newColumn;
-<# } #>
+                        return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.<#=method.MethodName#>(column.CloneAsDecimalColumn()._columnContainer));
 <# } else if (method.IsBitwise == true) { #>
                         throw new NotSupportedException();
 <# } else if (method.MethodType == MethodType.BinaryScalar) { #>
@@ -299,18 +284,12 @@ namespace Microsoft.Data.Analysis
                     if (typeof(U) == typeof(T))
                     {
                         // No conversions
-<# if (method.MethodType == MethodType.ComparisonScalar || method.MethodType == MethodType.Comparison) { #>
 <# if (method.MethodType == MethodType.ComparisonScalar) { #>
                         PrimitiveDataFrameColumn<T> primitiveColumn = this;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.<#=method.MethodName#>(Unsafe.As<U, T>(ref value), newColumn._columnContainer);
-                        return newColumn;
-<# } else { #>
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.<#=method.MethodName#>(Unsafe.As<U, T>(ref value)));
+<# } else if (method.MethodType == MethodType.Comparison) { #>
                         PrimitiveDataFrameColumn<U> primitiveColumn = this as PrimitiveDataFrameColumn<U>;
-                        PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
-                        primitiveColumn._columnContainer.<#=method.MethodName#>(column._columnContainer, newColumn._columnContainer);
-                        return newColumn;
-<# } #>
+                        return new BooleanDataFrameColumn(Name, primitiveColumn._columnContainer.<#=method.MethodName#>(column._columnContainer));
 <# } else if (method.IsBitwise == true ) { #>
                         throw new NotSupportedException();
 <# } else if (method.MethodType == MethodType.BinaryScalar ) { #>
@@ -340,17 +319,12 @@ namespace Microsoft.Data.Analysis
 <# } #>
                         if (typeof(U) == typeof(decimal))
                         {
-<# if (method.MethodType == MethodType.ComparisonScalar || method.MethodType == MethodType.Comparison) { #>
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
 <# if (method.MethodType == MethodType.ComparisonScalar) { #>
                             PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.<#=method.MethodName#>(DecimalConverter<U>.Instance.GetDecimal(value), newColumn._columnContainer);
-                            return newColumn;
-<# } else { #>
+                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.<#=method.MethodName#>(DecimalConverter<U>.Instance.GetDecimal(value)));
+<# } else if (method.MethodType == MethodType.Comparison) { #>
                             PrimitiveDataFrameColumn<decimal> decimalColumn = CloneAsDecimalColumn();
-                            decimalColumn._columnContainer.<#=method.MethodName#>((column as PrimitiveDataFrameColumn<decimal>)._columnContainer, newColumn._columnContainer);
-                            return newColumn;
-<# } #>
+                            return new BooleanDataFrameColumn(Name, decimalColumn._columnContainer.<#=method.MethodName#>((column as PrimitiveDataFrameColumn<decimal>)._columnContainer));
 <# } else if (method.IsBitwise == true) { #>
                             throw new NotSupportedException();
 <# } else if (method.MethodType == MethodType.BinaryScalar) { #>
@@ -365,17 +339,12 @@ namespace Microsoft.Data.Analysis
                         }
                         else
                         {
-<# if (method.MethodType == MethodType.ComparisonScalar || method.MethodType == MethodType.Comparison) { #>
-                            PrimitiveDataFrameColumn<bool> newColumn = CloneAsBooleanColumn();
 <# if (method.MethodType == MethodType.ComparisonScalar) { #>
                             PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.<#=method.MethodName#>(DoubleConverter<U>.Instance.GetDouble(value), newColumn._columnContainer);
-                            return newColumn;
-<# } else { #>
+                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.<#=method.MethodName#>(DoubleConverter<U>.Instance.GetDouble(value)));
+<# } else if (method.MethodType == MethodType.Comparison) { #>
                             PrimitiveDataFrameColumn<double> doubleColumn = CloneAsDoubleColumn();
-                            doubleColumn._columnContainer.<#=method.MethodName#>(column.CloneAsDoubleColumn()._columnContainer, newColumn._columnContainer);
-                            return newColumn;
-<# } #>
+                            return new BooleanDataFrameColumn(Name, doubleColumn._columnContainer.<#=method.MethodName#>(column.CloneAsDoubleColumn()._columnContainer));
 <# } else if (method.IsBitwise == true) { #>
                             throw new NotSupportedException();
 <# } else if (method.MethodType == MethodType.BinaryScalar ) { #>

From 1640b5952bb5a4581949376c624436608df3414e Mon Sep 17 00:00:00 2001
From: Aleksei Smirnov <tlalok@inbox.ru>
Date: Thu, 13 Jul 2023 18:12:44 +0300
Subject: [PATCH 4/6] Fix unit tests

---
 .../ColumnArithmeticTemplate.ttinclude        |   1 -
 .../PrimitiveDataFrameColumnArithmetic.cs     | 304 +++++++++---------
 .../PrimitiveDataFrameColumnArithmetic.tt     |   8 +-
 3 files changed, 158 insertions(+), 155 deletions(-)

diff --git a/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude b/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude
index 7109530e3b..dbe44c3889 100644
--- a/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude
+++ b/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude
@@ -438,7 +438,6 @@
                     return $"{dataFrameType}<{genericType}> {Op2Name}";
                 case MethodType.Contraction:
                     throw new ArgumentException();
-                    return $"{dataFrameType}<{genericType}> {Op1Name}, {dataFrameType}<{genericType}> {Op2Name}, int[] leftAxes, int[] rightAxes";
                 default:
                     throw new ArgumentException();
             }
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs
index 8c976fbcaf..89143a8316 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.cs
@@ -333,7 +333,7 @@ public void RightShift(PrimitiveColumnContainer<bool> column, int value)
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -349,7 +349,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<bool> column, bool scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -364,7 +364,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<bool> left, PrimitiveColumnContainer<bool> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -380,7 +380,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<bool> column, bool scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -784,7 +784,7 @@ public void RightShift(PrimitiveColumnContainer<byte> column, int value)
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -800,7 +800,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<byte> column, byte scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -815,7 +815,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -831,7 +831,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<byte> column, byte scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -846,7 +846,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -862,7 +862,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<byte> column, byte scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -877,7 +877,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -893,7 +893,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<byte> column, byte scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -908,7 +908,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -924,7 +924,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<byte> column, byte scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -939,7 +939,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<byte> left, PrimitiveColumnContainer<byte> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -955,7 +955,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContain
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<byte> column, byte scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1319,7 +1319,7 @@ public void RightShift(PrimitiveColumnContainer<char> column, int value)
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1335,7 +1335,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<char> column, char scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1350,7 +1350,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1366,7 +1366,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<char> column, char scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1381,7 +1381,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1397,7 +1397,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<char> column, char scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1412,7 +1412,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1428,7 +1428,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<char> column, char scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1443,7 +1443,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1459,7 +1459,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<char> column, char scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1474,7 +1474,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<char> left, PrimitiveColumnContainer<char> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1490,7 +1490,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContain
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<char> column, char scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1763,7 +1763,7 @@ public void RightShift(PrimitiveColumnContainer<decimal> column, int value)
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1779,7 +1779,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1794,7 +1794,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1810,7 +1810,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1825,7 +1825,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1841,7 +1841,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1856,7 +1856,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1872,7 +1872,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1887,7 +1887,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1903,7 +1903,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -1918,7 +1918,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<decimal> left, PrimitiveColumnContainer<decimal> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -1934,7 +1934,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContain
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<decimal> column, decimal scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2207,7 +2207,7 @@ public void RightShift(PrimitiveColumnContainer<double> column, int value)
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2223,7 +2223,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<double> column, double scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2238,7 +2238,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2254,7 +2254,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<double> column, double scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2269,7 +2269,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2285,7 +2285,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<double> column, double scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2300,7 +2300,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2316,7 +2316,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<double> column, double scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2331,7 +2331,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2347,7 +2347,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<double> column, double scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2362,7 +2362,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<double> left, PrimitiveColumnContainer<double> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2378,7 +2378,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContain
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<double> column, double scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2651,7 +2651,7 @@ public void RightShift(PrimitiveColumnContainer<float> column, int value)
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2667,7 +2667,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<float> column, float scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2682,7 +2682,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2698,7 +2698,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<float> column, float scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2713,7 +2713,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2729,7 +2729,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<float> column, float scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2744,7 +2744,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2760,7 +2760,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<float> column, float scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2775,7 +2775,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2791,7 +2791,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<float> column, float scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -2806,7 +2806,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<float> left, PrimitiveColumnContainer<float> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -2822,7 +2822,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContain
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<float> column, float scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3186,7 +3186,7 @@ public void RightShift(PrimitiveColumnContainer<int> column, int value)
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3202,7 +3202,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<int> column, int scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3217,7 +3217,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3233,7 +3233,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<int> column, int scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3248,7 +3248,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3264,7 +3264,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<int> column, int scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3279,7 +3279,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3295,7 +3295,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<int> column, int scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3310,7 +3310,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3326,7 +3326,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<int> column, int scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3341,7 +3341,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<int> left, PrimitiveColumnContainer<int> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3357,7 +3357,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContain
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<int> column, int scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3721,7 +3721,7 @@ public void RightShift(PrimitiveColumnContainer<long> column, int value)
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3737,7 +3737,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<long> column, long scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3752,7 +3752,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3768,7 +3768,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<long> column, long scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3783,7 +3783,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3799,7 +3799,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<long> column, long scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3814,7 +3814,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3830,7 +3830,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<long> column, long scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3845,7 +3845,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3861,7 +3861,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<long> column, long scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -3876,7 +3876,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<long> left, PrimitiveColumnContainer<long> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -3892,7 +3892,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContain
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<long> column, long scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4256,7 +4256,7 @@ public void RightShift(PrimitiveColumnContainer<sbyte> column, int value)
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4272,7 +4272,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4287,7 +4287,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4303,7 +4303,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4318,7 +4318,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4334,7 +4334,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4349,7 +4349,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4365,7 +4365,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4380,7 +4380,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4396,7 +4396,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4411,7 +4411,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<sbyte> left, PrimitiveColumnContainer<sbyte> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4427,7 +4427,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContain
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<sbyte> column, sbyte scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4791,7 +4791,7 @@ public void RightShift(PrimitiveColumnContainer<short> column, int value)
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4807,7 +4807,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<short> column, short scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4822,7 +4822,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4838,7 +4838,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<short> column, short scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4853,7 +4853,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4869,7 +4869,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<short> column, short scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4884,7 +4884,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4900,7 +4900,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<short> column, short scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4915,7 +4915,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4931,7 +4931,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<short> column, short scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -4946,7 +4946,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<short> left, PrimitiveColumnContainer<short> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -4962,7 +4962,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContain
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<short> column, short scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5326,7 +5326,7 @@ public void RightShift(PrimitiveColumnContainer<uint> column, int value)
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5342,7 +5342,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<uint> column, uint scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5357,7 +5357,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5373,7 +5373,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<uint> column, uint scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5388,7 +5388,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5404,7 +5404,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<uint> column, uint scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5419,7 +5419,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5435,7 +5435,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<uint> column, uint scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5450,7 +5450,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5466,7 +5466,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<uint> column, uint scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5481,7 +5481,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<uint> left, PrimitiveColumnContainer<uint> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5497,7 +5497,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContain
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<uint> column, uint scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5861,7 +5861,7 @@ public void RightShift(PrimitiveColumnContainer<ulong> column, int value)
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5877,7 +5877,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5892,7 +5892,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5908,7 +5908,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5923,7 +5923,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5939,7 +5939,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5954,7 +5954,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -5970,7 +5970,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -5985,7 +5985,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -6001,7 +6001,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -6016,7 +6016,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<ulong> left, PrimitiveColumnContainer<ulong> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -6032,7 +6032,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContain
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<ulong> column, ulong scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -6396,7 +6396,7 @@ public void RightShift(PrimitiveColumnContainer<ushort> column, int value)
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -6412,7 +6412,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -6427,7 +6427,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -6443,7 +6443,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -6458,7 +6458,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -6474,7 +6474,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -6489,7 +6489,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveCol
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -6505,7 +6505,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -6520,7 +6520,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumn
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -6536,7 +6536,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -6551,7 +6551,7 @@ public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnCont
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<ushort> left, PrimitiveColumnContainer<ushort> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -6567,7 +6567,7 @@ public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContain
 
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<ushort> column, ushort scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -6715,7 +6715,7 @@ public void RightShift(PrimitiveColumnContainer<DateTime> column, int value)
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -6731,7 +6731,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
@@ -6746,7 +6746,7 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<DateTime> left, PrimitiveColumnContainer<DateTime> right)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
             long index = 0;
             for (int b = 0; b < left.Buffers.Count; b++)
             {
@@ -6762,7 +6762,7 @@ public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContai
 
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<DateTime> column, DateTime scalar)
         {
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
             for (int b = 0; b < column.Buffers.Count; b++)
             {
diff --git a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt
index d158295b1a..9ad6e313ee 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt
+++ b/src/Microsoft.Data.Analysis/PrimitiveDataFrameColumnArithmetic.tt
@@ -68,8 +68,12 @@ namespace Microsoft.Data.Analysis
 <# if ((method.IsNumeric && !type.SupportsNumeric) || (method.IsBitwise && !type.SupportsBitwise) || (type.UnsupportedMethods.Contains(method.MethodName))) { #>
             throw new NotSupportedException();
 <# } else if (method.Operator != null) { #>
-<# if (method.MethodType == MethodType.Comparison || method.MethodType == MethodType.ComparisonScalar) { #>
-            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>();
+<# if (method.MethodType == MethodType.Comparison) { #>
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(left.Length);
+            long index = 0;
+<# } #>
+<# if (method.MethodType == MethodType.ComparisonScalar) { #>
+            PrimitiveColumnContainer<bool> ret = new PrimitiveColumnContainer<bool>(column.Length);
             long index = 0;
 <# } #>
             for (int b = 0; b < <#= method.Op1Name #>.Buffers.Count; b++)

From 942716935bf319847a189a6f05d3b7460cce98d2 Mon Sep 17 00:00:00 2001
From: Aleksei Smirnov <tlalok@inbox.ru>
Date: Thu, 13 Jul 2023 19:04:21 +0300
Subject: [PATCH 5/6] Fix spaces

---
 ...imitiveColumnContainer.BinaryOperations.cs | 20 +++++++++++++++++++
 ...imitiveColumnContainer.BinaryOperations.tt |  3 ++-
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs
index a17c888f36..ca16f01489 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs
+++ b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.cs
@@ -10,6 +10,7 @@ namespace Microsoft.Data.Analysis
     internal partial class PrimitiveColumnContainer<T>
         where T : unmanaged
     {
+
         public PrimitiveColumnContainer<T> Add(PrimitiveColumnContainer<T> right)
         {
             PrimitiveDataFrameColumnArithmetic<T>.Instance.Add(this, right);
@@ -122,85 +123,104 @@ public PrimitiveColumnContainer<bool> ElementwiseEquals(PrimitiveColumnContainer
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseEquals(this, right);
         }
+
         public PrimitiveColumnContainer<bool> ElementwiseEquals(T scalar)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseEquals(this, scalar);
         }
+
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(PrimitiveColumnContainer<T> right)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseNotEquals(this, right);
         }
+
         public PrimitiveColumnContainer<bool> ElementwiseNotEquals(T scalar)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseNotEquals(this, scalar);
         }
+
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(PrimitiveColumnContainer<T> right)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThanOrEqual(this, right);
         }
+
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThanOrEqual(T scalar)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThanOrEqual(this, scalar);
         }
+
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(PrimitiveColumnContainer<T> right)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThanOrEqual(this, right);
         }
+
         public PrimitiveColumnContainer<bool> ElementwiseLessThanOrEqual(T scalar)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThanOrEqual(this, scalar);
         }
+
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(PrimitiveColumnContainer<T> right)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThan(this, right);
         }
+
         public PrimitiveColumnContainer<bool> ElementwiseGreaterThan(T scalar)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseGreaterThan(this, scalar);
         }
+
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(PrimitiveColumnContainer<T> right)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThan(this, right);
         }
+
         public PrimitiveColumnContainer<bool> ElementwiseLessThan(T scalar)
         {
             return PrimitiveDataFrameColumnArithmetic<T>.Instance.ElementwiseLessThan(this, scalar);
         }
+
         public PrimitiveColumnContainer<T> ReverseAdd(T scalar)
         {
             PrimitiveDataFrameColumnArithmetic<T>.Instance.Add(scalar, this);
             return this;
         }
+
         public PrimitiveColumnContainer<T> ReverseSubtract(T scalar)
         {
             PrimitiveDataFrameColumnArithmetic<T>.Instance.Subtract(scalar, this);
             return this;
         }
+
         public PrimitiveColumnContainer<T> ReverseMultiply(T scalar)
         {
             PrimitiveDataFrameColumnArithmetic<T>.Instance.Multiply(scalar, this);
             return this;
         }
+
         public PrimitiveColumnContainer<T> ReverseDivide(T scalar)
         {
             PrimitiveDataFrameColumnArithmetic<T>.Instance.Divide(scalar, this);
             return this;
         }
+
         public PrimitiveColumnContainer<T> ReverseModulo(T scalar)
         {
             PrimitiveDataFrameColumnArithmetic<T>.Instance.Modulo(scalar, this);
             return this;
         }
+
         public PrimitiveColumnContainer<T> ReverseAnd(T scalar)
         {
             PrimitiveDataFrameColumnArithmetic<T>.Instance.And(scalar, this);
             return this;
         }
+
         public PrimitiveColumnContainer<T> ReverseOr(T scalar)
         {
             PrimitiveDataFrameColumnArithmetic<T>.Instance.Or(scalar, this);
             return this;
         }
+
         public PrimitiveColumnContainer<T> ReverseXor(T scalar)
         {
             PrimitiveDataFrameColumnArithmetic<T>.Instance.Xor(scalar, this);
diff --git a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt
index 9bdd5c9c85..4af33da261 100644
--- a/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt
+++ b/src/Microsoft.Data.Analysis/PrimitiveColumnContainer.BinaryOperations.tt
@@ -17,6 +17,7 @@ namespace Microsoft.Data.Analysis
         where T : unmanaged
     {
 <# foreach (MethodConfiguration method in methodConfiguration) { #>
+
 <# if (method.MethodType == MethodType.Comparison) { #>
         public PrimitiveColumnContainer<bool> <#=method.MethodName#>(PrimitiveColumnContainer<T> right)
         {
@@ -39,11 +40,11 @@ namespace Microsoft.Data.Analysis
 <# } #>
             return this;
         }
-
 <# } #>
 <# } #>
 <# foreach (MethodConfiguration method in methodConfiguration) { #>
 <# if (method.MethodType == MethodType.BinaryScalar) { #>
+
         public PrimitiveColumnContainer<T> Reverse<#=method.MethodName#>(T scalar)
         {
             PrimitiveDataFrameColumnArithmetic<T>.Instance.<#=method.MethodName#>(scalar, this);

From d98d15f8c149818d7df984b0b89649504602b13e Mon Sep 17 00:00:00 2001
From: Aleksei Smirnov <tlalok@inbox.ru>
Date: Tue, 18 Jul 2023 10:03:07 +0300
Subject: [PATCH 6/6] Fix code review findings

---
 .../ColumnArithmeticTemplate.ttinclude                      | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude b/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude
index dbe44c3889..2294023439 100644
--- a/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude
+++ b/src/Microsoft.Data.Analysis/ColumnArithmeticTemplate.ttinclude
@@ -400,13 +400,11 @@
                 case MethodType.UnaryInPlace:
                     return $"{dataFrameType}<{genericType}> {Op1Name}";
                 case MethodType.BinaryScalar:
-                    return $"{dataFrameType}<{genericType}> {Op1Name}, {genericType} {Op2Name}";
                 case MethodType.ComparisonScalar:
                     return $"{dataFrameType}<{genericType}> {Op1Name}, {genericType} {Op2Name}";
                 case MethodType.BinaryInt:
                     return $"{dataFrameType}<{genericType}> {Op1Name}, int {Op2Name}";
                 case MethodType.Binary:
-                    return $"{dataFrameType}<{genericType}> {Op1Name}, {dataFrameType}<{genericType}> {Op2Name}";
                 case MethodType.Comparison:
                     return $"{dataFrameType}<{genericType}> {Op1Name}, {dataFrameType}<{genericType}> {Op2Name}";
                 case MethodType.Contraction:
@@ -427,13 +425,11 @@
                 case MethodType.UnaryInPlace:
                     throw new ArgumentException();
                 case MethodType.BinaryScalar:
-                    return $"{genericType} {Op2Name}";
                 case MethodType.ComparisonScalar:
                     return $"{genericType} {Op2Name}";
                 case MethodType.BinaryInt:
                     return $"int {Op2Name}";
                 case MethodType.Binary:
-                    return $"{dataFrameType}<{genericType}> {Op2Name}";
                 case MethodType.Comparison:
                     return $"{dataFrameType}<{genericType}> {Op2Name}";
                 case MethodType.Contraction:
@@ -448,4 +444,4 @@
         public bool HasReturnValue { get; }
         public bool SupportsRowSubsets { get; }
     }
-#>
+#>
\ No newline at end of file