nextcloud · dependabot · Dec 19, 2025 · Dec 19, 2025
diff --git a/brick/math/src/BigDecimal.php b/brick/math/src/BigDecimal.php
@@ -8,6 +8,7 @@
 use Brick\Math\Exception\MathException;
 use Brick\Math\Exception\NegativeNumberException;
 use Brick\Math\Internal\Calculator;
+use Override;
 
 /**
  * Immutable, arbitrary-precision signed decimal numbers.
@@ -47,6 +48,7 @@ protected function __construct(string $value, int $scale = 0)
     /**
      * @psalm-pure
      */
+    #[Override]
     protected static function from(BigNumber $number): static
     {
         return $number->toBigDecimal();
@@ -58,19 +60,23 @@ protected static function from(BigNumber $number): static
      * Example: `(12345, 3)` will result in the BigDecimal `12.345`.
      *
      * @param BigNumber|int|float|string $value The unscaled value. Must be convertible to a BigInteger.
-     * @param int                        $scale The scale of the number, positive or zero.
-     *
-     * @throws \InvalidArgumentException If the scale is negative.
+     * @param int                        $scale The scale of the number. If negative, the scale will be set to zero
+     *                                          and the unscaled value will be adjusted accordingly.
      *
      * @psalm-pure
      */
     public static function ofUnscaledValue(BigNumber|int|float|string $value, int $scale = 0) : BigDecimal
     {
+        $value = (string) BigInteger::of($value);
+
         if ($scale < 0) {
-            throw new \InvalidArgumentException('The scale cannot be negative.');
+            if ($value !== '0') {
+                $value .= \str_repeat('0', -$scale);
+            }
+            $scale = 0;
         }
 
-        return new BigDecimal((string) BigInteger::of($value), $scale);
+        return new BigDecimal($value, $scale);
     }
 
     /**
@@ -535,6 +541,7 @@ public function negated() : BigDecimal
         return new BigDecimal(Calculator::get()->neg($this->value), $this->scale);
     }
 
+    #[Override]
     public function compareTo(BigNumber|int|float|string $that) : int
     {
         $that = BigNumber::of($that);
@@ -552,6 +559,7 @@ public function compareTo(BigNumber|int|float|string $that) : int
         return - $that->compareTo($this);
     }
 
+    #[Override]
     public function getSign() : int
     {
         return ($this->value === '0') ? 0 : (($this->value[0] === '-') ? -1 : 1);
@@ -567,6 +575,33 @@ public function getScale() : int
         return $this->scale;
     }
 
+    /**
+     * Returns the number of significant digits in the number.
+     *
+     * This is the number of digits to both sides of the decimal point, stripped of leading zeros.
+     * The sign has no impact on the result.
+     *
+     * Examples:
+     *   0 => 0
+     *   0.0 => 0
+     *   123 => 3
+     *   123.456 => 6
+     *   0.00123 => 3
+     *   0.0012300 => 5
+     */
+    public function getPrecision(): int
+    {
+        $value = $this->value;
+
+        if ($value === '0') {
+            return 0;
+        }
+
+        $length = \strlen($value);
+
+        return ($value[0] === '-') ? $length - 1 : $length;
+    }
+
     /**
      * Returns a string representing the integral part of this decimal number.
      *
@@ -609,18 +644,21 @@ public function hasNonZeroFractionalPart() : bool
         return $this->getFractionalPart() !== \str_repeat('0', $this->scale);
     }
 
+    #[Override]
     public function toBigInteger() : BigInteger
     {
         $zeroScaleDecimal = $this->scale === 0 ? $this : $this->dividedBy(1, 0);
 
         return self::newBigInteger($zeroScaleDecimal->value);
     }
 
+    #[Override]
     public function toBigDecimal() : BigDecimal
     {
         return $this;
     }
 
+    #[Override]
     public function toBigRational() : BigRational
     {
         $numerator = self::newBigInteger($this->value);
@@ -629,6 +667,7 @@ public function toBigRational() : BigRational
         return self::newBigRational($numerator, $denominator, false);
     }
 
+    #[Override]
     public function toScale(int $scale, RoundingMode $roundingMode = RoundingMode::UNNECESSARY) : BigDecimal
     {
         if ($scale === $this->scale) {
@@ -638,24 +677,32 @@ public function toScale(int $scale, RoundingMode $roundingMode = RoundingMode::U
         return $this->dividedBy(BigDecimal::one(), $scale, $roundingMode);
     }
 
+    #[Override]
     public function toInt() : int
     {
         return $this->toBigInteger()->toInt();
     }
 
+    #[Override]
     public function toFloat() : float
     {
         return (float) (string) $this;
     }
 
+    /**
+     * @return numeric-string
+     */
+    #[Override]
     public function __toString() : string
     {
         if ($this->scale === 0) {
+            /** @var numeric-string */
             return $this->value;
         }
 
         $value = $this->getUnscaledValueWithLeadingZeros();
 
+        /** @var numeric-string */
         return \substr($value, 0, -$this->scale) . '.' . \substr($value, -$this->scale);
     }
 

diff --git a/brick/math/src/BigInteger.php b/brick/math/src/BigInteger.php
@@ -10,6 +10,7 @@
 use Brick\Math\Exception\NegativeNumberException;
 use Brick\Math\Exception\NumberFormatException;
 use Brick\Math\Internal\Calculator;
+use Override;
 
 /**
  * An arbitrary-size integer.
@@ -42,6 +43,7 @@ protected function __construct(string $value)
     /**
      * @psalm-pure
      */
+    #[Override]
     protected static function from(BigNumber $number): static
     {
         return $number->toBigInteger();
@@ -856,6 +858,7 @@ public function testBit(int $n) : bool
         return $this->shiftedRight($n)->isOdd();
     }
 
+    #[Override]
     public function compareTo(BigNumber|int|float|string $that) : int
     {
         $that = BigNumber::of($that);
@@ -867,31 +870,37 @@ public function compareTo(BigNumber|int|float|string $that) : int
         return - $that->compareTo($this);
     }
 
+    #[Override]
     public function getSign() : int
     {
         return ($this->value === '0') ? 0 : (($this->value[0] === '-') ? -1 : 1);
     }
 
+    #[Override]
     public function toBigInteger() : BigInteger
     {
         return $this;
     }
 
+    #[Override]
     public function toBigDecimal() : BigDecimal
     {
         return self::newBigDecimal($this->value);
     }
 
+    #[Override]
     public function toBigRational() : BigRational
     {
         return self::newBigRational($this, BigInteger::one(), false);
     }
 
+    #[Override]
     public function toScale(int $scale, RoundingMode $roundingMode = RoundingMode::UNNECESSARY) : BigDecimal
     {
         return $this->toBigDecimal()->toScale($scale, $roundingMode);
     }
 
+    #[Override]
     public function toInt() : int
     {
         $intValue = (int) $this->value;
@@ -903,6 +912,7 @@ public function toInt() : int
         return $intValue;
     }
 
+    #[Override]
     public function toFloat() : float
     {
         return (float) $this->value;
@@ -1013,8 +1023,13 @@ public function toBytes(bool $signed = true) : string
         return \hex2bin($hex);
     }
 
+    /**
+     * @return numeric-string
+     */
+    #[Override]
     public function __toString() : string
     {
+        /** @var numeric-string */
         return $this->value;
     }
 

diff --git a/brick/math/src/BigNumber.php b/brick/math/src/BigNumber.php
@@ -8,6 +8,7 @@
 use Brick\Math\Exception\MathException;
 use Brick\Math\Exception\NumberFormatException;
 use Brick\Math\Exception\RoundingNecessaryException;
+use Override;
 
 /**
  * Common interface for arbitrary-precision rational numbers.
@@ -51,8 +52,9 @@ abstract class BigNumber implements \JsonSerializable
      * - strings containing a `.` character or using an exponential notation are returned as BigDecimal
      * - strings containing only digits with an optional leading `+` or `-` sign are returned as BigInteger
      *
-     * @throws NumberFormatException   If the format of the number is not valid.
+     * @throws NumberFormatException If the format of the number is not valid.
      * @throws DivisionByZeroException If the value represents a rational number with a denominator of zero.
+     * @throws RoundingNecessaryException If the value cannot be converted to an instance of the subclass without rounding.
      *
      * @psalm-pure
      */
@@ -71,6 +73,9 @@ final public static function of(BigNumber|int|float|string $value) : static
     }
 
     /**
+     * @throws NumberFormatException If the format of the number is not valid.
+     * @throws DivisionByZeroException If the value represents a rational number with a denominator of zero.
+     *
      * @psalm-pure
      */
     private static function _of(BigNumber|int|float|string $value) : BigNumber
@@ -163,7 +168,7 @@ private static function _of(BigNumber|int|float|string $value) : BigNumber
     /**
      * Overridden by subclasses to convert a BigNumber to an instance of the subclass.
      *
-     * @throws MathException If the value cannot be converted.
+     * @throws RoundingNecessaryException If the value cannot be converted.
      *
      * @psalm-pure
      */
@@ -502,6 +507,7 @@ abstract public function toFloat() : float;
      */
     abstract public function __toString() : string;
 
+    #[Override]
     final public function jsonSerialize() : string
     {
         return $this->__toString();

diff --git a/brick/math/src/BigRational.php b/brick/math/src/BigRational.php
@@ -8,6 +8,7 @@
 use Brick\Math\Exception\MathException;
 use Brick\Math\Exception\NumberFormatException;
 use Brick\Math\Exception\RoundingNecessaryException;
+use Override;
 
 /**
  * An arbitrarily large rational number.
@@ -57,6 +58,7 @@ protected function __construct(BigInteger $numerator, BigInteger $denominator, b
     /**
      * @psalm-pure
      */
+    #[Override]
     protected static function from(BigNumber $number): static
     {
         return $number->toBigRational();
@@ -320,16 +322,19 @@ public function simplified() : BigRational
         return new BigRational($numerator, $denominator, false);
     }
 
+    #[Override]
     public function compareTo(BigNumber|int|float|string $that) : int
     {
         return $this->minus($that)->getSign();
     }
 
+    #[Override]
     public function getSign() : int
     {
         return $this->numerator->getSign();
     }
 
+    #[Override]
     public function toBigInteger() : BigInteger
     {
         $simplified = $this->simplified();
@@ -341,32 +346,38 @@ public function toBigInteger() : BigInteger
         return $simplified->numerator;
     }
 
+    #[Override]
     public function toBigDecimal() : BigDecimal
     {
         return $this->numerator->toBigDecimal()->exactlyDividedBy($this->denominator);
     }
 
+    #[Override]
     public function toBigRational() : BigRational
     {
         return $this;
     }
 
+    #[Override]
     public function toScale(int $scale, RoundingMode $roundingMode = RoundingMode::UNNECESSARY) : BigDecimal
     {
         return $this->numerator->toBigDecimal()->dividedBy($this->denominator, $scale, $roundingMode);
     }
 
+    #[Override]
     public function toInt() : int
     {
         return $this->toBigInteger()->toInt();
     }
 
+    #[Override]
     public function toFloat() : float
     {
         $simplified = $this->simplified();
         return $simplified->numerator->toFloat() / $simplified->denominator->toFloat();
     }
 
+    #[Override]
     public function __toString() : string
     {
         $numerator   = (string) $this->numerator;
@@ -376,7 +387,7 @@ public function __toString() : string
             return $numerator;
         }
 
-        return $this->numerator . '/' . $this->denominator;
+        return $numerator . '/' . $denominator;
     }
 
     /**

diff --git a/brick/math/src/Exception/MathException.php b/brick/math/src/Exception/MathException.php
@@ -7,6 +7,6 @@
 /**
  * Base class for all math exceptions.
  */
-class MathException extends \Exception
+class MathException extends \RuntimeException
 {
 }