Add round, ceil, floor, truncate to the In-Database Column type

distribution/lib/Standard/Table/0.0.0-dev/src/Data/Table.enso

@@ -1311,7 +1311,8 @@ type Table
        Create a constant column from a value.
     make_constant_column : Any -> Column
     make_constant_column self value =
-        Column.from_vector_repeated ("Constant_" + UUID.randomUUID.to_text) [value] self.row_count
+        if Table_Helpers.is_column value then Error.throw (Illegal_Argument.Error "A constant value may only be created from a scalar, not a Column") else
+            Column.from_vector_repeated ("Constant_" + UUID.randomUUID.to_text) [value] self.row_count
 
     ## Returns the vector of columns contained in this table.
 

std-bits/table/src/main/java/org/enso/table/data/column/operation/map/DoubleLongMapOpWithSpecialNumericHandling.java

@@ -0,0 +1,38 @@
+package org.enso.table.data.column.operation.map;
+
+import java.util.BitSet;
+import org.enso.table.data.column.storage.numeric.DoubleStorage;
+import org.enso.table.data.column.storage.numeric.LongStorage;
+
+public abstract class DoubleLongMapOpWithSpecialNumericHandling
+    extends UnaryMapOperationWithProblemBuilder<Double, DoubleStorage> {
+  public DoubleLongMapOpWithSpecialNumericHandling(String name) {
+    super(name);
+  }
+
+  protected abstract long doOperation(double a);
+
+  @Override
+  public LongStorage run(
+      DoubleStorage storage, Object arg, MapOperationProblemBuilder problemBuilder) {
+    long[] out = new long[storage.size()];
+    BitSet isMissing = new BitSet();
+
+    for (int i = 0; i < storage.size(); i++) {
+      if (!storage.isNa(i)) {
+        double item = storage.getItem(i);
+        boolean special = Double.isNaN(item) || Double.isInfinite(item);
+        if (!special) {
+          out[i] = doOperation(item);
+        } else {
+          String msg = "Value is " + item;
+          problemBuilder.reportArithmeticError(msg, i);
+          isMissing.set(i);
+        }
+      } else {
+        isMissing.set(i);
+      }
+    }
+    return new LongStorage(out, storage.size(), isMissing);
+  }
+}

std-bits/table/src/main/java/org/enso/table/data/column/operation/map/UnaryMapOperationWithProblemBuilder.java

@@ -0,0 +1,28 @@
+package org.enso.table.data.column.operation.map;
+
+import org.enso.table.data.column.storage.Storage;
+
+/**
+ * A map-like operation that ignores its second argument
+ *
+ * @param <I> the supported storage type
+ */
+public abstract class UnaryMapOperationWithProblemBuilder<T, I extends Storage<T>>
+    extends MapOperation<T, I> {
+  public UnaryMapOperationWithProblemBuilder(String name) {
+    super(name);
+  }
+
+  protected abstract Storage<?> run(
+      I storage, Object arg, MapOperationProblemBuilder problemBuilder);
+
+  @Override
+  public Storage<?> runMap(I storage, Object arg, MapOperationProblemBuilder problemBuilder) {
+    return run(storage, arg, problemBuilder);
+  }
+
+  @Override
+  public Storage<?> runZip(I storage, Storage<?> arg, MapOperationProblemBuilder problemBuilder) {
+    return run(storage, arg, problemBuilder);
+  }
+}

std-bits/table/src/main/java/org/enso/table/data/column/storage/numeric/DoubleStorage.java

@@ -4,9 +4,9 @@
 import java.util.List;
 import org.enso.table.data.column.builder.Builder;
 import org.enso.table.data.column.builder.NumericBuilder;
+import org.enso.table.data.column.operation.map.DoubleLongMapOpWithSpecialNumericHandling;
 import org.enso.table.data.column.operation.map.MapOpStorage;
 import org.enso.table.data.column.operation.map.MapOperationProblemBuilder;
-import org.enso.table.data.column.operation.map.UnaryDoubleToLongOp;
 import org.enso.table.data.column.operation.map.UnaryMapOperation;
 import org.enso.table.data.column.operation.map.numeric.DoubleBooleanOp;
 import org.enso.table.data.column.operation.map.numeric.DoubleIsInOp;
@@ -245,21 +245,21 @@ protected double doDouble(
               }
             })
         .add(
-            new UnaryDoubleToLongOp(Maps.TRUNCATE) {
+            new DoubleLongMapOpWithSpecialNumericHandling(Maps.TRUNCATE) {
               @Override
               protected long doOperation(double a) {
                 return (long) a;
               }
             })
         .add(
-            new UnaryDoubleToLongOp(Maps.CEIL) {
+            new DoubleLongMapOpWithSpecialNumericHandling(Maps.CEIL) {
               @Override
               protected long doOperation(double a) {
                 return (long) Math.ceil(a);
               }
             })
         .add(
-            new UnaryDoubleToLongOp(Maps.FLOOR) {
+            new DoubleLongMapOpWithSpecialNumericHandling(Maps.FLOOR) {
               @Override
               protected long doOperation(double a) {
                 return (long) Math.floor(a);

test/Table_Tests/src/Common_Table_Operations/Column_Operations_Spec.enso

@@ -512,14 +512,6 @@ spec setup =
             table = table_builder [["x", [0, 3, -3, 1, -2]]]
             table.at "x" . round 16 . should_fail_with Illegal_Argument
 
-        Test.specify "Can handle NaN/Infinity" <|
-            nan_result = if setup.test_selection.is_nan_and_nothing_distinct then Number.nan else Nothing
-            ops = [.round, .truncate, .ceil, .floor]
-            ops.each op->
-                do_op Number.nan op . should_equal nan_result
-                do_op Number.positive_infinity op . should_equal Number.positive_infinity
-                do_op Number.negative_infinity op . should_equal Number.negative_infinity
-
         if setup.test_selection.supports_decimal_type then
             Test.specify "should return decimals when rounding decimals" <|
                 i1 = 9223372036854775807 - 1
@@ -647,69 +639,55 @@ spec setup =
             do_round -3.50001 . should_equal -4
             do_round -3.99999 . should_equal -4
 
-        Test.specify "Returns the correct type" <|
-            do_round 231.2 1 . should_be_a Decimal
-            do_round 231.2 0 . should_be_a Decimal
-            do_round 231.2 . should_be_a Decimal
-            do_round 231.2 -1 . should_be_a Decimal
-
         Test.specify "Can round correctly near the precision limit" <|
             do_round 1.22222222225 10 . should_equal 1.2222222223
             do_round 1.222222222225 11 . should_equal 1.22222222223
             do_round 1.2222222222225 12 . should_equal 1.222222222223
             do_round 1.22222222222225 13 . should_equal 1.2222222222223
             do_round 1.222222222222225 14 . should_equal 1.22222222222223
-            do_round 1.2222222222222225 15 . should_equal 1.222222222222223
 
             do_round -1.22222222225 10 . should_equal -1.2222222223
             do_round -1.222222222225 11 . should_equal -1.22222222223
             do_round -1.2222222222225 12 . should_equal -1.222222222223
             do_round -1.22222222222225 13 . should_equal -1.2222222222223
             do_round -1.222222222222225 14 . should_equal -1.22222222222223
-            do_round -1.2222222222222225 15 . should_equal -1.222222222222223
 
             do_round 1.22222222235 10 . should_equal 1.2222222224
             do_round 1.222222222235 11 . should_equal 1.22222222224
             do_round 1.2222222222235 12 . should_equal 1.222222222224
             do_round 1.22222222222235 13 . should_equal 1.2222222222224
             do_round 1.222222222222235 14 . should_equal 1.22222222222224
-            do_round 1.2222222222222235 15 . should_equal 1.222222222222224
 
             do_round -1.22222222235 10 . should_equal -1.2222222224
             do_round -1.222222222235 11 . should_equal -1.22222222224
             do_round -1.2222222222235 12 . should_equal -1.222222222224
             do_round -1.22222222222235 13 . should_equal -1.2222222222224
             do_round -1.222222222222235 14 . should_equal -1.22222222222224
-            do_round -1.2222222222222235 15 . should_equal -1.222222222222224
 
         Test.specify "Can round correctly near the precision limit, using banker's rounding" <|
             do_round 1.22222222225 10 use_bankers=True . should_equal 1.2222222222
             do_round 1.222222222225 11 use_bankers=True . should_equal 1.22222222222
             do_round 1.2222222222225 12 use_bankers=True . should_equal 1.222222222222
             do_round 1.22222222222225 13 use_bankers=True . should_equal 1.2222222222222
             do_round 1.222222222222225 14 use_bankers=True . should_equal 1.22222222222222
-            do_round 1.2222222222222225 15 use_bankers=True . should_equal 1.222222222222222
 
             do_round -1.22222222225 10 use_bankers=True . should_equal -1.2222222222
             do_round -1.222222222225 11 use_bankers=True . should_equal -1.22222222222
             do_round -1.2222222222225 12 use_bankers=True . should_equal -1.222222222222
             do_round -1.22222222222225 13 use_bankers=True . should_equal -1.2222222222222
             do_round -1.222222222222225 14 use_bankers=True . should_equal -1.22222222222222
-            do_round -1.2222222222222225 15 use_bankers=True . should_equal -1.222222222222222
 
             do_round 1.22222222235 10 use_bankers=True . should_equal 1.2222222224
             do_round 1.222222222235 11 use_bankers=True . should_equal 1.22222222224
             do_round 1.2222222222235 12 use_bankers=True . should_equal 1.222222222224
             do_round 1.22222222222235 13 use_bankers=True . should_equal 1.2222222222224
             do_round 1.222222222222235 14 use_bankers=True . should_equal 1.22222222222224
-            do_round 1.2222222222222235 15 use_bankers=True . should_equal 1.222222222222224
 
             do_round -1.22222222235 10 use_bankers=True . should_equal -1.2222222224
             do_round -1.222222222235 11 use_bankers=True . should_equal -1.22222222224
             do_round -1.2222222222235 12 use_bankers=True . should_equal -1.222222222224
             do_round -1.22222222222235 13 use_bankers=True . should_equal -1.2222222222224
             do_round -1.222222222222235 14 use_bankers=True . should_equal -1.22222222222224
-            do_round -1.2222222222222235 15 use_bankers=True . should_equal -1.222222222222224
 
         Test.specify "Decimal places out of range" <|
             do_round 3.1 16 . should_fail_with Illegal_Argument
@@ -812,12 +790,6 @@ spec setup =
             do_round -12250 -2 use_bankers=True . should_equal -12200
             do_round -12251 -2 use_bankers=True . should_equal -12300
 
-        Test.specify "Returns the correct type" <|
-            do_round 231 1 . should_be_a Decimal
-            do_round 231 0 . should_be_a Decimal
-            do_round 231 . should_be_a Decimal
-            do_round 231 -1 . should_be_a Decimal
-
     Test.group prefix+"Text Column Operations" <|
         t3 = table_builder [["s1", ["foobar", "bar", "baz", "BAB", Nothing]], ["s2", ["foo", "ar", "a", "b", Nothing]]]
         s1 = t3.at "s1"

test/Table_Tests/src/Database/Postgres_Spec.enso

@@ -223,6 +223,32 @@ postgres_specific_spec connection db_name setup =
             col . cast Value_Type.Integer . truncate . value_type . should_equal Value_Type.Float
             col . cast Value_Type.Decimal . truncate . value_type . should_equal Value_Type.Decimal
 
+        do_op n op =
+            table = table_builder [["x", [n]]]
+            result = table.at "x" |> op
+            result.to_vector.at 0
+        do_round n dp=0 use_bankers=False = do_op n (_.round dp use_bankers)
+
+        Test.specify "Can handle NaN/Infinity" <|
+            nan_result = if setup.test_selection.is_nan_and_nothing_distinct then Number.nan else Nothing
+            ops = [.round, .truncate, .ceil, .floor]
+            ops.each op->
+                do_op Number.nan op . should_equal nan_result
+                do_op Number.positive_infinity op . should_equal Number.positive_infinity
+                do_op Number.negative_infinity op . should_equal Number.negative_infinity
+
+        Test.specify "round returns the correct type" <|
+            do_round 231.2 1 . should_be_a Decimal
+            do_round 231.2 0 . should_be_a Decimal
+            do_round 231.2 . should_be_a Decimal
+            do_round 231.2 -1 . should_be_a Decimal
+
+        Test.specify "round returns the correct type" <|
+            do_round 231 1 . should_be_a Decimal
+            do_round 231 0 . should_be_a Decimal
+            do_round 231 . should_be_a Decimal
+            do_round 231 -1 . should_be_a Decimal
+
 run_tests connection db_name =
     prefix = "[PostgreSQL] "
     name_counter = Ref.new 0

test/Table_Tests/src/Database/SQLite_Spec.enso

@@ -151,6 +151,32 @@ sqlite_specific_spec prefix connection setup =
             col . cast Value_Type.Integer . truncate . value_type . should_equal Value_Type.Integer
             col . cast Value_Type.Decimal . truncate . value_type . should_equal Value_Type.Float
 
+        do_op n op =
+            table = table_builder [["x", [n]]]
+            result = table.at "x" |> op
+            result.to_vector.at 0
+        do_round n dp=0 use_bankers=False = do_op n (_.round dp use_bankers)
+
+        Test.specify "Can handle NaN/Infinity" <|
+            nan_result = if setup.test_selection.is_nan_and_nothing_distinct then Number.nan else Nothing
+            ops = [.round, .truncate, .ceil, .floor]
+            ops.each op->
+                do_op Number.nan op . should_equal nan_result
+                do_op Number.positive_infinity op . should_equal Number.positive_infinity
+                do_op Number.negative_infinity op . should_equal Number.negative_infinity
+
+        Test.specify "round returns the correct type" <|
+            do_round 231.2 1 . should_be_a Decimal
+            do_round 231.2 0 . should_be_a Decimal
+            do_round 231.2 . should_be_a Decimal
+            do_round 231.2 -1 . should_be_a Decimal
+
+        Test.specify "round returns the correct type" <|
+            do_round 231 1 . should_be_a Decimal
+            do_round 231 0 . should_be_a Decimal
+            do_round 231 . should_be_a Decimal
+            do_round 231 -1 . should_be_a Decimal
+
 sqlite_spec connection prefix =
     name_counter = Ref.new 0
     table_builder columns =

test/Table_Tests/src/In_Memory/Column_Spec.enso

@@ -2,6 +2,7 @@ from Standard.Base import all
 
 import project.Util
 
+import Standard.Base.Errors.Common.Arithmetic_Error
 import Standard.Base.Errors.Common.Index_Out_Of_Bounds
 import Standard.Base.Errors.Illegal_Argument.Illegal_Argument
 import Standard.Examples
@@ -169,6 +170,36 @@ spec =
         Test.specify "Should error on input of the wrong type" <|
             Column.from_vector "foo" ["asdf", "zxcv", "qwer"] . floor . should_fail_with Invalid_Value_Type
 
+    Test.group "round/truncate/ceil/floor" <|
+        do_op n op =
+            col = Column.from_vector "x" [n]
+            result = op col
+            result.to_vector.at 0
+        do_round n dp=0 use_bankers=False = do_op n (_.round dp use_bankers)
+
+        Test.specify "round returns the correct type" <|
+            do_round 231.2 1 . should_be_a Decimal
+            do_round 231.2 0 . should_be_a Integer
+            do_round 231.2 . should_be_a Integer
+            do_round 231.2 -1 . should_be_a Integer
+
+        Test.specify "round returns the correct type" <|
+            do_round 231 1 . should_be_a Integer
+            do_round 231 0 . should_be_a Integer
+            do_round 231 . should_be_a Integer
+            do_round 231 -1 . should_be_a Integer
+
+        Test.specify "nan/inf" <|
+            ops = [.truncate, .ceil, .floor, .round]
+            ops.map op->
+                col = Column.from_vector "x" [2.1, 0.0, Number.nan, Number.positive_infinity, Number.negative_infinity, Nothing, 12.1]
+                result = op col
+                result.to_vector . drop 2 . take 4 . should_equal [Nothing, Nothing, Nothing, Nothing]
+                warnings = Warning.get_all result . map .value
+                warnings . should_contain <| Arithmetic_Error.Error 'Value is -Infinity (at rows [4]).'
+                warnings . should_contain <| Arithmetic_Error.Error 'Value is Infinity (at rows [3]).'
+                warnings . should_contain <| Arithmetic_Error.Error 'Value is NaN (at rows [2]).'
+
     Test.group "Date_Time truncate" <|
         Test.specify "should be able to truncate a column of Date_Times" <|
             Column.from_vector "foo" [Date_Time.new 2020 10 24 1 2 3, Date_Time.new 2020 10 24 1 2 3] . truncate . should_equal <| Column.from_vector "foo" [Date.new 2020 10 24, Date.new 2020 10 24]