BigDecimalBuilder and arithmetic operations.

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

@@ -31,6 +31,7 @@ import project.Value_Type.Value_Type
 from project.Errors import Conversion_Failure, Floating_Point_Equality, Inexact_Type_Coercion, Invalid_Column_Names, Invalid_Value_Type, No_Index_Set_Error
 from project.Internal.Column_Format import all
 from project.Internal.Java_Exports import make_date_builder_adapter, make_string_builder
+from project.Internal.Storage import enso_to_java, java_to_enso
 
 polyglot java import org.enso.base.Time_Utils
 polyglot java import org.enso.table.data.column.operation.cast.CastProblemAggregator
@@ -102,7 +103,7 @@ type Column
         Invalid_Column_Names.handle_java_exception <| Polyglot_Helpers.handle_polyglot_dataflow_errors <| handle_invalid_value_type <|
             java_column = Java_Problems.with_problem_aggregator Problem_Behavior.Report_Warning java_problem_aggregator->
                 case needs_polyglot_conversion of
-                    True -> Java_Column.fromItems name items expected_storage_type java_problem_aggregator
+                    True -> Java_Column.fromItems name (items.map enso_to_java) expected_storage_type java_problem_aggregator
                     False -> Java_Column.fromItemsNoDateConversion name items expected_storage_type java_problem_aggregator
             result = Column.Value java_column . throw_on_warning Conversion_Failure
             result.catch Conversion_Failure error->
@@ -137,7 +138,7 @@ type Column
 
        Arguments:
        - java_column: The internal representation of the column.
-    private Value java_column
+    Value java_column
 
     ## PRIVATE
        ADVANCED
@@ -2111,7 +2112,7 @@ type Column
     @index (self-> Numeric_Input minimum=0 maximum=self.length-1)
     at : Integer -> (Any | Nothing) ! Index_Out_Of_Bounds
     at self (index : Integer) =
-        self.get index (Error.throw (Index_Out_Of_Bounds.Error index self.length))
+        java_to_enso <| self.get index (Error.throw (Index_Out_Of_Bounds.Error index self.length))
 
     ## GROUP Standard.Base.Selections
        ICON select_row
@@ -2158,7 +2159,7 @@ type Column
 
              example_to_vector = Examples.integer_column.to_vector
     to_vector : Vector
-    to_vector self = Vector.from_polyglot_array self.java_column.getStorage.toList
+    to_vector self = Vector.from_polyglot_array self.java_column.getStorage.toList . map java_to_enso
 
     ## GROUP Standard.Base.Metadata
        ICON metadata
@@ -2458,7 +2459,7 @@ run_vectorized_binary_op column name operand new_name=Nothing fallback_fn=Nothin
             _ ->
                 s1 = column.java_column.getStorage
                 rs = Polyglot_Helpers.handle_polyglot_dataflow_errors <|
-                    s1.vectorizedOrFallbackBinaryMap name problem_builder fallback_fn operand skip_nulls storage_type
+                    s1.vectorizedOrFallbackBinaryMap name problem_builder fallback_fn (enso_to_java operand) skip_nulls storage_type
                 Column.Value (Java_Column.new effective_new_name rs)
 
 ## PRIVATE

distribution/lib/Standard/Table/0.0.0-dev/src/Internal/Storage.enso

@@ -8,8 +8,11 @@ import project.Value_Type.Bits
 import project.Value_Type.Value_Type
 from project.Errors import Inexact_Type_Coercion
 
+polyglot java import java.math.BigDecimal
+
 polyglot java import org.enso.table.data.column.builder.Builder as Java_Builder
 polyglot java import org.enso.table.data.column.storage.type.AnyObjectType
+polyglot java import org.enso.table.data.column.storage.type.BigDecimalType
 polyglot java import org.enso.table.data.column.storage.type.BigIntegerType
 polyglot java import org.enso.table.data.column.storage.type.Bits as Java_Bits
 polyglot java import org.enso.table.data.column.storage.type.BooleanType
@@ -40,6 +43,7 @@ to_value_type storage_type = case storage_type of
     _ : DateType -> Value_Type.Date
     _ : DateTimeType -> Value_Type.Date_Time with_timezone=True
     _ : TimeOfDayType -> Value_Type.Time
+    _ : BigDecimalType -> Value_Type.Decimal
     _ : BigIntegerType -> Value_Type.Decimal scale=0
     _ : AnyObjectType -> Value_Type.Mixed
 
@@ -64,11 +68,18 @@ closest_storage_type value_type = case value_type of
     Value_Type.Mixed -> AnyObjectType.INSTANCE
     Value_Type.Decimal _ scale ->
         is_integer = scale.is_nothing || scale <= 0
-        if is_integer then BigIntegerType.INSTANCE else
-            Error.throw (Illegal_Argument.Error "Columns of type "+value_type.to_display_text+" are currently not supported in the in-memory backend - only Decimal of integer type (scale <= 0) is supported. You may cast the column to Float first (lossy conversion).")
+        if is_integer then BigIntegerType.INSTANCE else BigDecimalType.INSTANCE
     _ ->
         Error.throw (Illegal_Argument.Error "Columns of type "+value_type.to_display_text+" are currently not supported in the in-memory backend.")
 
+enso_to_java x = case x of
+    Decimal.Value big_decimal -> big_decimal
+    _ -> x
+
+java_to_enso x = case x of
+    _ : BigDecimal -> Decimal.Value x
+    _ -> x
+
 ## PRIVATE
    Converts a value type to an in-memory storage type, possibly approximating it
    to the closest supported type.

distribution/lib/Standard/Table/0.0.0-dev/src/Internal/Value_Type_Helpers.enso

@@ -25,6 +25,7 @@ most_specific_value_type : Any -> Boolean -> Value_Type
 most_specific_value_type value use_smallest=False =
     case value of
         _ : Float       -> Value_Type.Float Bits.Bits_64
+        _ : Decimal     -> Value_Type.Decimal
         _ : Boolean     -> Value_Type.Boolean
         _ : Date        -> Value_Type.Date
         _ : Time_Of_Day -> Value_Type.Time

std-bits/base/src/main/java/org/enso/base/polyglot/NumericConverter.java

@@ -18,6 +18,11 @@
  * want to be consistent with Enso's equality semantics where 2 == 2.0.
  */
 public class NumericConverter {
+  public static BigInteger INTEGER_MIN_VALUE_BIG_INTEGER = BigInteger.valueOf(Integer.MIN_VALUE);
+  public static BigInteger INTEGER_MAX_VALUE_BIG_INTEGER = BigInteger.valueOf(Integer.MAX_VALUE);
+  public static BigDecimal INTEGER_MIN_VALUE_BIG_DECIMAL = BigDecimal.valueOf(Integer.MIN_VALUE);
+  public static BigDecimal INTEGER_MAX_VALUE_BIG_DECIMAL = BigDecimal.valueOf(Integer.MAX_VALUE);
+
   /**
    * Coerces a number (possibly an integer) to a Double.
    *
@@ -59,14 +64,32 @@ public static BigInteger coerceToBigInteger(Object o) {
     }
   }
 
+  /**
+   * Coerces a number to a BigDecimal.
+   *
+   * <p>Will throw an exception if the object is not a number.
+   */
+  public static BigDecimal coerceToBigDecimal(Object o) {
+    return switch (o) {
+      case Double x -> BigDecimal.valueOf(x);
+      case BigDecimal x -> x;
+      case Float x -> BigDecimal.valueOf(x);
+      case BigInteger x -> new BigDecimal(x);
+      case Long x -> BigDecimal.valueOf(x);
+      case Integer x -> BigDecimal.valueOf(x);
+      case Short x -> BigDecimal.valueOf(x);
+      case Byte x -> BigDecimal.valueOf(x);
+      default -> throw new UnsupportedOperationException("Cannot coerce " + o + " to a BigDecimal.");
+    };
+  }
+
   /** Returns true if the object is any supported number. */
   public static boolean isCoercibleToDouble(Object o) {
     return isFloatLike(o)|| isCoercibleToLong(o) || o instanceof BigInteger;
   }
 
   public static boolean isFloatLike(Object o) {
     return o instanceof Double
-        || o instanceof BigDecimal
         || o instanceof Float;
   }
 
@@ -102,6 +125,77 @@ public static Double tryConvertingToDouble(Object o) {
     };
   }
 
+  /**
+   * Tries converting the value to an Integer.
+   *
+   * <p>Decimal number types are accepted, only if their fractional part is 0. It will return null
+   * if the object represented a non-integer value. Integer values must fit within the Integer range.
+   */
+  public static Integer tryConvertingToInteger(Object o) {
+    return switch (o) {
+      case Long x -> fitsInInt(x) ? x.intValue() : null;
+      case Integer x -> x;
+      case Short x -> (int) x;
+      case Byte x -> (int) x;
+      case Double x -> integralDoubleToInteger(x);
+      case Float x -> integralDoubleToInteger(x);
+      case BigDecimal x -> integralBigDecimalToInteger(x);
+      case BigInteger x -> integralBigIntegerToInteger(x);
+      case null, default -> null;
+    };
+  }
+
+  private static boolean fitsInInt(long x) {
+    return x >= Integer.MIN_VALUE && x <= Integer.MAX_VALUE;
+  }
+
+  private static boolean fitsInInt(BigInteger x) {
+    return x.compareTo(INTEGER_MIN_VALUE_BIG_INTEGER) >= 0 && x.compareTo(INTEGER_MAX_VALUE_BIG_INTEGER) <= 0;
+  }
+
+  private static boolean fitsInInt(BigDecimal x) {
+    return x.compareTo(INTEGER_MIN_VALUE_BIG_DECIMAL) >= 0 && x.compareTo(INTEGER_MAX_VALUE_BIG_DECIMAL) <= 0;
+  }
+
+  /**
+   * Converts a double to an Integer, if the value is integral and fits in the
+   * Integer range. Otherwise, returns null;
+   */
+  private static Integer integralDoubleToInteger(double x) {
+    if (x % 1.0 == 0.0) {
+      long l = (long) x;
+      if (fitsInInt(l)) {
+        return (int) l;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Converts a BigInteger to an Integer, if the value fits in the Integer
+   * range. Otherwise, returns null;
+   */
+  private static Integer integralBigIntegerToInteger(BigInteger x) {
+    if (fitsInInt(x)) {
+      return x.intValueExact();
+    } else {
+      return null;
+    }
+  }
+
+  /**
+   * Converts a BigDecmal to an Integer, if the value is integral and fits in
+   * the Integer range. Otherwise, returns null;
+   */
+  private static Integer integralBigDecimalToInteger(BigDecimal x) {
+    if (x.remainder(BigDecimal.ZERO).equals(BigDecimal.ZERO)) {
+      if (fitsInInt(x)) {
+        return x.intValueExact();
+      }
+    }
+    return null;
+  }
+
   /**
    * Tries converting the value to a Long.
    *

std-bits/base/src/main/java/org/enso/base/polyglot/Polyglot_Utils.java

@@ -35,6 +35,7 @@ public static Object convertPolyglotValue(Value item) {
     if (item.isException()) {
       throw new WrappedDataflowError(item);
     }
+
     var ret = item.as(Object.class);
     if (ret instanceof BigInteger && item.fitsInLong()) {
       return item.asLong();

std-bits/table/src/main/java/org/enso/table/data/column/builder/BigDecimalBuilder.java

@@ -0,0 +1,50 @@
+package org.enso.table.data.column.builder;
+
+import java.math.BigDecimal;
+
+import org.enso.table.data.column.storage.Storage;
+import org.enso.table.data.column.storage.numeric.BigDecimalStorage;
+import org.enso.table.data.column.storage.type.BigDecimalType;
+import org.enso.table.data.column.storage.type.StorageType;
+import org.enso.table.error.ValueTypeMismatchException;
+
+/** A builder for BigDecimal columns. */
+public class BigDecimalBuilder extends TypedBuilderImpl<BigDecimal> {
+  @Override
+  protected BigDecimal[] newArray(int size) {
+    return new BigDecimal[size];
+  }
+
+  public BigDecimalBuilder(int size) {
+    super(size);
+  }
+
+  @Override
+  public StorageType getType() {
+    return BigDecimalType.INSTANCE;
+  }
+
+  @Override
+  public void appendNoGrow(Object o) {
+    try {
+      data[currentSize++] = (BigDecimal) o;
+    } catch (ClassCastException e) {
+      throw new ValueTypeMismatchException(getType(), o);
+    }
+  }
+
+  @Override
+  public void append(Object o) {
+    appendNoGrow(o);
+  }
+
+  @Override
+  public boolean accepts(Object o) {
+    return o instanceof BigDecimal;
+  }
+
+  @Override
+  protected Storage<BigDecimal> doSeal() {
+    return new BigDecimalStorage(data, currentSize);
+  }
+}

std-bits/table/src/main/java/org/enso/table/data/column/builder/DateBuilder.java

@@ -7,7 +7,7 @@
 import org.enso.table.data.column.storage.type.StorageType;
 import org.enso.table.error.ValueTypeMismatchException;
 
-/** A builder for string columns. */
+/** A builder for LocalDate columns. */
 public class DateBuilder extends TypedBuilderImpl<LocalDate> {
   @Override
   protected LocalDate[] newArray(int size) {

std-bits/table/src/main/java/org/enso/table/data/column/builder/DateTimeBuilder.java

@@ -7,7 +7,7 @@
 import org.enso.table.data.column.storage.type.StorageType;
 import org.enso.table.error.ValueTypeMismatchException;
 
-/** A builder for string columns. */
+/** A builder for ZonedDateTime columns. */
 public class DateTimeBuilder extends TypedBuilderImpl<ZonedDateTime> {
   @Override
   protected ZonedDateTime[] newArray(int size) {

std-bits/table/src/main/java/org/enso/table/data/column/builder/InferredBuilder.java

@@ -1,5 +1,6 @@
 package org.enso.table.data.column.builder;
 
+import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.time.LocalDate;
 import java.time.LocalTime;
@@ -115,6 +116,8 @@ private void initBuilderFor(Object o) {
       currentBuilder = new StringBuilder(initialCapacity, TextType.VARIABLE_LENGTH);
     } else if (o instanceof BigInteger) {
       currentBuilder = new BigIntegerBuilder(initialCapacity, problemAggregator);
+    } else if (o instanceof BigDecimal) {
+      currentBuilder = new BigDecimalBuilder(initialCapacity);
     } else if (o instanceof LocalDate) {
       currentBuilder = new DateBuilder(initialCapacity);
     } else if (o instanceof LocalTime) {

std-bits/table/src/main/java/org/enso/table/data/column/builder/TimeOfDayBuilder.java

@@ -7,7 +7,7 @@
 import org.enso.table.data.column.storage.type.TimeOfDayType;
 import org.enso.table.error.ValueTypeMismatchException;
 
-/** A builder for string columns. */
+/** A builder for LocalTime columns. */
 public class TimeOfDayBuilder extends TypedBuilderImpl<LocalTime> {
   @Override
   protected LocalTime[] newArray(int size) {

std-bits/table/src/main/java/org/enso/table/data/column/operation/map/numeric/arithmetic/AddOp.java

@@ -1,8 +1,10 @@
 package org.enso.table.data.column.operation.map.numeric.arithmetic;
 
+import java.math.BigDecimal;
 import java.math.BigInteger;
 import org.enso.table.data.column.operation.map.MapOperationProblemAggregator;
 import org.enso.table.data.column.storage.Storage;
+import org.enso.table.data.column.storage.numeric.BigDecimalStorage;
 import org.enso.table.data.column.storage.type.IntegerType;
 
 public class AddOp<T extends Number, I extends Storage<? super T>>
@@ -32,4 +34,10 @@ public BigInteger doBigInteger(
       BigInteger a, BigInteger b, int ix, MapOperationProblemAggregator problemAggregator) {
     return a.add(b);
   }
+
+  @Override
+  public BigDecimal doBigDecimal(
+      BigDecimal a, BigDecimal b, int ix, MapOperationProblemAggregator problemAggregator) {
+    return a.add(b);
+  }
 }

std-bits/table/src/main/java/org/enso/table/data/column/operation/map/numeric/arithmetic/BigDecimalDivideOp.java

@@ -0,0 +1,19 @@
+package org.enso.table.data.column.operation.map.numeric.arithmetic;
+
+import java.math.BigDecimal;
+
+import org.enso.table.data.column.operation.map.MapOperationProblemAggregator;
+import org.enso.table.data.column.storage.Storage;
+
+public class BigDecimalDivideOp<T extends Number, I extends Storage<? super T>>
+    extends NumericBinaryOpReturningBigDecimal<T, I> {
+  public BigDecimalDivideOp() {
+    super(Storage.Maps.DIV);
+  }
+
+  @Override
+  public BigDecimal doBigDecimal(
+      BigDecimal a, BigDecimal b, int ix, MapOperationProblemAggregator problemAggregator) {
+    return a.divide(b);
+  }
+}