[integer][decimal] Improve error messages and remove unnecessary raises (#92)

Improve error messages and remove unnecessary `raises`.

Author: forfudan

src/decimojo/bigdecimal/arithmetics.mojo

@@ -162,7 +162,7 @@ fn subtract(x1: BigDecimal, x2: BigDecimal) raises -> BigDecimal:
         return BigDecimal(coefficient=BigUInt.ZERO, scale=max_scale, sign=False)
 
 
-fn multiply(x1: BigDecimal, x2: BigDecimal) raises -> BigDecimal:
+fn multiply(x1: BigDecimal, x2: BigDecimal) -> BigDecimal:
     """Returns the product of two numbers.
 
     Args:

src/decimojo/bigdecimal/bigdecimal.mojo

@@ -122,13 +122,27 @@ struct BigDecimal(
         self = Self.from_uint(value)
 
     @implicit
-    fn __init__(out self, value: Scalar):
+    fn __init__[dtype: DType, //](out self, value: SIMD[dtype, 1]):
         """Constructs a BigDecimal from an integral scalar.
         This includes all SIMD integral types, such as Int8, Int16, UInt32, etc.
 
         Constraints:
             The dtype of the scalar must be integral.
         """
+        constrained[
+            dtype.is_integral(),
+            (
+                "\n***********************************************************\n"
+                "BigDecimal does not allow floating-point numbers as input to"
+                " avoid unintentional loss of precision. If you want to create"
+                " a BigDecimal from a floating-point number, please consider"
+                " wrapping it with quotation marks or using the"
+                " `BigDecimal.from_float()` (or `BDec.from_float()`) method"
+                " instead."
+                "\n***********************************************************"
+            ),
+        ]()
+
         self = Self.from_integral_scalar(value)
 
     # ===------------------------------------------------------------------=== #
@@ -474,7 +488,7 @@ struct BigDecimal(
         return decimojo.bigdecimal.arithmetics.subtract(self, other)
 
     @always_inline
-    fn __mul__(self, other: Self) raises -> Self:
+    fn __mul__(self, other: Self) -> Self:
         return decimojo.bigdecimal.arithmetics.multiply(self, other)
 
     @always_inline
@@ -776,6 +790,9 @@ struct BigDecimal(
         Returns:
             A new BigDecimal with increased precision.
 
+        Raises:
+            Error: If `precision_diff` is negative.
+
         Examples:
         ```
         print(BigDecimal("123.456).scale_up(5))  # Output: 123.45600000
@@ -786,7 +803,7 @@ struct BigDecimal(
         """
         if precision_diff < 0:
             raise Error(
-                "Error in `extend_precision()`: "
+                "`extend_precision()`: "
                 "Cannot extend precision with negative value"
             )
 

src/decimojo/biguint/arithmetics.mojo

@@ -198,6 +198,9 @@ fn subtract(x1: BigUInt, x2: BigUInt) raises -> BigUInt:
         x1: The first unsigned integer (minuend).
         x2: The second unsigned integer (subtrahend).
 
+    Raises:
+        Error: If x2 is greater than x1, resulting in an underflow.
+
     Returns:
         The result of subtracting x2 from x1.
     """
@@ -206,7 +209,7 @@ fn subtract(x1: BigUInt, x2: BigUInt) raises -> BigUInt:
         return x1
     if x1.is_zero():
         # x2 is not zero, so the result is negative, raise an error
-        raise Error("Error in `subtract`: Underflow due to x1 < x2")
+        raise Error("biguint.arithmetics.subtract(): Underflow due to x1 < x2")
 
     # We need to determine which number has the larger magnitude
     var comparison_result = x1.compare(x2)
@@ -216,7 +219,7 @@ fn subtract(x1: BigUInt, x2: BigUInt) raises -> BigUInt:
         return BigUInt()  # Return zero
 
     if comparison_result < 0:
-        raise Error("Error in `subtract`: Underflow due to x1 < x2")
+        raise Error("biguint.arithmetics.subtract(): Underflow due to x1 < x2")
 
     # Now it is safe to subtract the smaller number from the larger one
     # The result will have no more words than the larger operand
@@ -251,13 +254,16 @@ fn negative(x: BigUInt) raises -> BigUInt:
     Args:
         x: The BigUInt value to compute the negative of.
 
+    Raises:
+        Error: If x is not zero, as negative of non-zero unsigned integer is undefined.
+
     Returns:
         A new BigUInt containing the negative of x.
     """
     if not x.is_zero():
         raise Error(
-            "Error in `negative`: Negative of non-zero unsigned integer is"
-            " undefined"
+            "biguint.arithmetics.negative(): Negative of non-zero unsigned"
+            " integer is undefined"
         )
     return BigUInt()  # Return zero
 
@@ -274,7 +280,7 @@ fn absolute(x: BigUInt) -> BigUInt:
     return x
 
 
-fn multiply(x1: BigUInt, x2: BigUInt) raises -> BigUInt:
+fn multiply(x1: BigUInt, x2: BigUInt) -> BigUInt:
     """Returns the product of two BigUInt numbers.
 
     Args:
@@ -359,7 +365,7 @@ fn floor_divide(x1: BigUInt, x2: BigUInt) raises -> BigUInt:
     if len(x2.words) == 1:
         # SUB-CASE: Division by zero
         if x2.words[0] == 0:
-            raise Error("Error in `truncate_divide`: Division by zero")
+            raise Error("biguint.arithmetics.floor_divide(): Division by zero")
 
         # SUB-CASE: Division by one
         if x2.words[0] == 1:
@@ -488,7 +494,7 @@ fn ceil_divide(x1: BigUInt, x2: BigUInt) raises -> BigUInt:
 
     # CASE: Division by zero
     if x2.is_zero():
-        raise Error("Error in `ceil_divide`: Division by zero")
+        raise Error("biguint.arithmetics.ceil_divide(): Division by zero")
 
     # Apply floor division and check if there is a remainder
     var quotient = floor_divide(x1, x2)
@@ -850,10 +856,14 @@ fn floor_divide_inplace_by_double_words(
     Args:
         x1: The BigUInt value to divide by the divisor.
         x2: The double-word divisor.
+
+    Raises:
+        Error: If the divisor is zero.
     """
     if x2.is_zero():
         raise Error(
-            "Error in `floor_divide_inplace_by_double_words`: Division by zero"
+            "biguint.arithmetics.floor_divide_inplace_by_double_words():"
+            " Division by zero"
         )
 
     # CASE: all other situations
@@ -911,12 +921,16 @@ fn scale_down_by_power_of_10(x: BigUInt, n: Int) raises -> BigUInt:
         x: The BigUInt value to multiply.
         n: The power of 10 to multiply by.
 
+    Raises:
+        Error: If n is negative.
+
     Returns:
         A new BigUInt containing the result of the multiplication.
     """
     if n < 0:
         raise Error(
-            "Error in `scale_down_by_power_of_10`: n must be non-negative"
+            "biguint.arithmetics.scale_down_by_power_of_10(): "
+            "n must be non-negative"
         )
     if n == 0:
         return x
@@ -1038,7 +1052,9 @@ fn shift_words_left(num: BigUInt, positions: Int) -> BigUInt:
 fn power_of_10(n: Int) raises -> BigUInt:
     """Calculates 10^n efficiently."""
     if n < 0:
-        raise Error("Error in `power_of_10`: Negative exponent not supported")
+        raise Error(
+            "biguint.arithmetics.power_of_10(): Negative exponent not supported"
+        )
 
     if n == 0:
         return BigUInt(1)

src/decimojo/biguint/biguint.mojo

@@ -136,8 +136,18 @@ struct BigUInt(Absable, IntableRaising, Stringable, Writable):
     fn __init__(out self, value: Int) raises:
         """Initializes a BigUInt from an Int.
         See `from_int()` for more information.
+
+        Raises:
+            Error: Calling `BigUInt.from_int()`.
         """
-        self = Self.from_int(value)
+        try:
+            self = Self.from_int(value)
+        except e:
+            raise Error(
+                "`BigUInt.__init__()`: Error calling"
+                " `BigUInt.from_int()`.\nTrace back:"
+                + String(e)
+            )
 
     @implicit
     fn __init__(out self, value: UInt):
@@ -245,7 +255,12 @@ struct BigUInt(Absable, IntableRaising, Stringable, Writable):
             return Self()
 
         if value < 0:
-            raise Error("Error in `BigUInt.from_int()`: The value is negative")
+            raise Error(
+                "`BigUInt.from_int()`: The input value ",
+                value,
+                " is negative and is not compatible with BigUInt.",
+                sep="",
+            )
 
         var list_of_words = List[UInt32]()
         var remainder: Int = value
@@ -806,15 +821,15 @@ struct BigUInt(Absable, IntableRaising, Stringable, Writable):
     # ===------------------------------------------------------------------=== #
 
     @always_inline
-    fn __add__(self, other: Self) raises -> Self:
+    fn __add__(self, other: Self) -> Self:
         return decimojo.biguint.arithmetics.add(self, other)
 
     @always_inline
     fn __sub__(self, other: Self) raises -> Self:
         return decimojo.biguint.arithmetics.subtract(self, other)
 
     @always_inline
-    fn __mul__(self, other: Self) raises -> Self:
+    fn __mul__(self, other: Self) -> Self:
         return decimojo.biguint.arithmetics.multiply(self, other)
 
     @always_inline

src/decimojo/decimal/exponential.mojo

@@ -448,11 +448,20 @@ fn exp(x: Decimal) raises -> Decimal:
     Returns:
         A Decimal approximation of e^x.
 
+    Raises:
+        Error: If x is greater than 66.54.
+
     Notes:
         Because ln(2^96-1) ~= 66.54212933375474970405428366,
         the x value should be no greater than 66 to avoid overflow.
     """
 
+    if x > Decimal.from_int(value=6654, scale=UInt32(2)):
+        raise Error(
+            "decimal.exponential.exp(): x is too large. It must be no greater"
+            " than 66.54 to avoid overflow. Consider using `BigDecimal` type."
+        )
+
     # Handle special cases
     if x.is_zero():
         return Decimal.ONE()